package test:guestresource;

interface bootstrap {
    resource myresource {
        constructor();
        dosomething: func();
    }
    init: func() -> result<myresource>;
}


world guestresource {
    export bootstrap;
}

use std::cell::RefCell;

use exports::test::guestresource::bootstrap::Guest;
use exports::test::guestresource::bootstrap::GuestMyresource;
use exports::test::guestresource::bootstrap::Myresource;

wit_bindgen::generate!({
    world: "guestresource",
    path: "../../wit",
});

struct MyresourceImpl {
    data: RefCell<Vec<u32>>,
}

impl GuestMyresource for MyresourceImpl {
    fn new() -> Self {
        MyresourceImpl{
            data: RefCell::new(vec![])
        }
    }

    fn dosomething(&self,) {
        let mut data = self.data.borrow_mut();
        data.push(1);
    }
}

export!(Impl);

struct Impl;

impl Guest for Impl {
    type Myresource = MyresourceImpl;

    fn init() -> Result<Myresource,()> {
        let mri = MyresourceImpl::new();
        let mr = Myresource::new(mri);
        Ok(mr)
    }
}

use wasmtime::{component::{Component, Linker}, Config, Engine, Store};
use wasmtime_wasi::{DirPerms, FilePerms, ResourceTable, WasiCtx, WasiCtxBuilder, WasiView};

mod myresource;

pub struct Ctx {
    table: ResourceTable,
    wasi: WasiCtx,
}

impl WasiView for Ctx {
    fn ctx(&mut self) -> &mut WasiCtx {
        &mut self.wasi
    }
    fn table(&mut self) -> &mut ResourceTable {
        &mut self.table
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut config = Config::new();
    config.wasm_component_model(true);
    config.async_support(true);


    let engine = Engine::new(&config)?;
    let mut linker: Linker<Ctx> = Linker::new(&engine);
    wasmtime_wasi::add_to_linker_async(&mut linker)?;
    let component = Component::from_file(&engine, "./guest.component.wasm")?;
    let wasi = WasiCtxBuilder::new()
    .preopened_dir(
        "./",
        "/",
        DirPerms::all(),
        FilePerms::all(),
    ).unwrap()
    .inherit_stdio()
    .build();
    let table = ResourceTable::new();

    let ctx = Ctx {
        wasi: wasi,
        table: table,
    };
    let mut store: Store<Ctx> = Store::new(
        &engine,
        ctx
    );

    let pre = myresource::GuestresourcePre::new(linker.instantiate_pre(&component).unwrap())?;
    let instance = pre.instantiate_async(&mut store).await?;
    let result = instance.test_guestresource_bootstrap().call_init(&mut store).await?;
    let ra = result.unwrap();
    let gmr = ra.try_into_resource::<myresource::exports::test::guestresource::bootstrap::GuestMyresource>(&mut store)?;
    let gm = store.data_mut().table().get(&gmr)?;
    gm.call_dosomething(&mut store, ra).await?;
    Ok(())
}

wasmtime::component::bindgen!({
    path: "./wit",
    world: "guestresource",
    async: true,
});

    gm.call_dosomething(&mut store, ra).await?;