interface content {
  use mime-registry.{mime-info};

  type error = string;

  resource content-reader {
    stream-from: func(offset: u64) -> result<stream<u8>, error>;
    read-to-end: async func() -> result<list<u8>, error>;
  }

  record content {
    url: string,
    info: mime-info,
    length: option<u64>,
    content: content-reader,
  }
}

interface network-provider {
  use content.{content, error};
  set-supported-encodings: async func(encodings: list<string>);
  fetch: async func(url: string) -> result<content, error>;
}

world network {
  import mime-registry;
  export content;
  export network-provider;
}

interface view-provider {
  use content.{content, error};

  variant input-event {
    window-resize(tuple<u32, u32>),
  }

  record frame {
    width: u32,
    height: u32,
    bytes: list<u8>,
  }

  load: async func(content: content) -> result<u8, string>;
  on-input: func(event: input-event);
  needs-redraw: func() -> bool;
  render: func() -> frame;
}

world view {
  import content;
  export view-provider;
}

world omnishell {
  include network;
  include archive;
  include compression;
  include view;
}

pub mod network {
    pub use super::bindings::exports::omnishell::provider::network_provider::*;
    use super::{Component, Linker, OmnishellManifest, Store};
    use url::Url;

    pub struct NetworkPlugin {
        schemes: Vec<String>,
        component: Component,
    }

    impl NetworkPlugin {
        pub fn new(manifest: OmnishellManifest, component: Component) -> Result<Self, String> {
            Ok(Self {
                schemes: manifest.provides.schemes,
                component,
            })
        }

        pub fn schemes(&self) -> &[String] {
            &self.schemes
        }

        pub async fn fetch(
            &self,
            store: &mut Store,
            linker: &Linker,
            url: &Url,
            supported_encodings: Vec<String>,
        ) -> Result<Content, String> {
            let instance_pre = linker
                .instantiate_pre(&self.component)
                .map_err(|e| format!("failed to pre-instantiate: {e}"))?;
            let guest_indices = GuestIndices::new(&instance_pre)
                .map_err(|e| format!("failed to read guest indices: {e}"))?;
            let instance = instance_pre
                .instantiate_async(&mut *store)
                .await
                .map_err(|err| format!("failed to instantiate: {err}"))?;
            let guest = guest_indices.load(&mut *store, &instance).unwrap();
            let content = store
                .run_concurrent(async |accessor| {
                    guest
                        .call_set_supported_encodings(accessor, supported_encodings)
                        .await
                        .map_err(|e| e.to_string())?;
                    guest
                        .call_fetch(accessor, url.to_string())
                        .await
                        .map_err(|e| e.to_string())?
                })
                .await
                .map_err(|e| e.to_string())??;
            Ok(content)
        }
    }
}

    pub async fn open(&self, url: Url) -> Result<(Url, WasmWidgetState), String> {
        let mut store = Store::new(
            &self.engine,
            HostState {
                table: ResourceTable::new(),
                ctx: wasmtime_wasi::WasiCtxBuilder::new()
                    .inherit_stdout()
                    .build(),
                http_ctx: wasmtime_wasi_http::WasiHttpCtx::new(),
            },
        );
        let content = self.fetch(&mut store, url).await?;
        let url: Url = content
            .url
            .parse()
            .map_err(|err| format!("invalid url {}: {err}", &content.url))?;
        let plugin = self.view_plugin(&content.info.mime)?;
        let guest = plugin
            .load(&mut store, &self.linker, content)
            .await
            .unwrap();
        Ok((url, WasmWidgetState::new(store, guest)))
    }

use wasmtime::component::{Component, Linker, Store};

// 1. Instantiate the dependency first
let mut linker: Linker<MyState> = Linker::new(&engine);
let dependency_instance = linker.instantiate(&mut store, &dependency_component)?;

// 2. Setup a fresh, clean linker for the plugin
let mut plugin_linker: Linker<MyState> = Linker::new(&engine);

// 3. THE PREMADE WAY: Fetch the entire interface block from the dependency
let content_export = dependency_instance
    .get_export(&mut store, None, "ns:pkg/content")
    .expect("Dependency must export the interface");

// 4. Feed the entire exported block into the plugin's required import slot
plugin_linker.instance("ns:pkg/content")?
    .add_export(&content_export)?; // This maps all functions AND resources natively

// 5. Instantiate the plugin safely
let plugin_instance = plugin_linker.instantiate(&mut store, &plugin_component)?;

            let content_reader = GuestContentReader::new(&mut *store, &instance, content.content);
            let resource = store.data_mut().table.push(content_reader).unwrap();
            content.content = resource.try_into_resource_any(&mut *store).unwrap();
            Ok(content)

    #[derive(Clone)]
    pub struct GuestContentReader {
        guest: Guest,
        reader: ResourceAny,
    }

    impl GuestContentReader {
        pub fn new(store: &mut Store, instance: &Instance, reader: ResourceAny) -> Self {
            let guest_indices = GuestIndices::new(&instance.instance_pre(&mut *store)).unwrap();
            let guest = guest_indices.load(&mut *store, &instance).unwrap();
            Self { guest, reader }
        }

        pub async fn read_to_end(&self, accessor: &Accessor) -> Result<Vec<u8>, String> {
            self.guest
                .content_reader()
                .call_read_to_end(accessor, self.reader)
                .await
                .unwrap()
        }

        pub fn stream_from(
            &self,
            store: impl AsContextMut,
            offset: u64,
        ) -> Result<StreamReader<u8>, String> {
            self.guest
                .content_reader()
                .call_stream_from(store, self.reader, offset)
                .unwrap()
        }
    }

    impl content::Host for HostState {}

    impl content::HostContentReader for HostState {
        fn stream_from(
            &mut self,
            rep: Resource<content::ContentReader>,
            offset: u64,
        ) -> Result<StreamReader<u8>, String> {
            let rep: Resource<GuestContentReader> = unsafe { std::mem::transmute(rep) };
            let reader = self
                .table
                .get(&rep)
                .map_err(|e| format!("Failed to look up reader: {e}"))?;
            //reader.stream_from(self, offset)
            todo!()
        }

        fn drop(&mut self, rep: Resource<content::ContentReader>) -> Result<(), wasmtime::Error> {
            self.table.delete(rep)?;
            Ok(())
        }
    }

    impl content::HostContentReaderWithStore<HostState> for HasSelf<HostState> {
        async fn read_to_end(
            cx: &Accessor,
            rep: Resource<content::ContentReader>,
        ) -> Result<Vec<u8>, String> {
            let rep: Resource<GuestContentReader> = unsafe { std::mem::transmute(rep) };
            let reader = cx
                .with(|mut access| {
                    let host_state = access.data_mut();
                    let reader: &GuestContentReader = host_state
                        .table
                        .get(&rep)
                        .map_err(|e| format!("Reader handle not found: {e}"))?;
                    Ok::<_, String>(reader.clone())
                })
                .unwrap();
            reader.read_to_end(cx).await.map_err(|e| e.to_string())
        }
    }

impl shell_provider::HostWithStore<HostState> for HasSelf<HostState> {
    async fn fetch_bytes(cx: &Accessor, url: String) -> Option<(String, Vec<u8>)> {
        let url = url.parse().ok()?;
        let shell = cx.with(|mut access| access.data_mut().shell.clone());
        let (url, bytes) = shell.fetch_bytes(url).await?;
        Some((url.to_string(), bytes))
    }

    async fn fetch_view(cx: &Accessor, url: String) -> Option<u32> {
        let url = url.parse().ok()?;
        let shell = cx.with(|mut access| access.data_mut().shell.clone());
        let (_url, view) = shell.fetch_view(url).await?;
        let id = cx.with(|mut access| {
            let children = &mut access.data_mut().children;
            let id = children.len();
            children.push(view);
            id
        });
        Some(id as u32)
    }
}
#[derive(Clone)]
pub struct ShellAction {
    tx: mpsc::UnboundedSender<ShellCommand>,
}

impl ShellAction {
    pub fn navigate(&self, url: Url) {
        self.tx.send(ShellCommand::Navigate(url)).unwrap();
    }

    pub async fn fetch_bytes(&self, url: Url) -> Option<(Url, Vec<u8>)> {
        let (tx, rx) = oneshot::channel();
        self.tx
            .send(ShellCommand::FetchBytes(url.clone(), tx))
            .unwrap();
        tracing::info!("waiting for response");
        // HERE future is dropped, how is it possible??
        let (url, bytes) = match rx.await {
            Ok((url, bytes)) => (url, bytes),
            Err(_) => {
                tracing::error!("fetch_bytes {url} oneshot tx dropped");
                return None;
            }
        };
        tracing::info!("received bytes for url {url}");
        Some((url, bytes))
    }

    pub async fn fetch_view(&self, url: Url) -> Option<(Url, WasmWidgetState)> {
        let (tx, rx) = oneshot::channel();
        self.tx.send(ShellCommand::FetchView(url, tx)).unwrap();
        rx.await.ok()
    }
}