use std::cell::RefCell;
use std::collections::BTreeMap;
use std::fs::{File, OpenOptions, create_dir_all};
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::time::Instant;

use eyre::Result;
use tinywasm::{FuncContext, HostFunction, Imports, ModuleInstance, Store};

const IMPORT_MODULE: &str = "env";
pub const SCREEN_WIDTH: usize = 320;
pub const SCREEN_HEIGHT: usize = 200;

pub struct Runtime {
    store: Store,
    update: tinywasm::FunctionTyped<(), ()>,
    framebuffer: tinywasm::FunctionTyped<(), i32>,
    key_down: tinywasm::FunctionTyped<i32, ()>,
    key_up: tinywasm::FunctionTyped<i32, ()>,
    memory: tinywasm::Memory,
    framebuffer_bytes: Vec<u8>,
    pub host_state: Rc<RefCell<HostState>>,
}

impl Runtime {
    pub fn new(wad_path: PathBuf, guest_path: PathBuf) -> Result<Self> {
        let module = tinywasm::parse_file(&guest_path)?;
        let mut store = Store::default();
        let host_state = Rc::new(RefCell::new(HostState::new(wad_path)));
        let imports = build_imports(&mut store, host_state.clone());
        let instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))?;

        let wad_path_buf = instance.func::<(), i32>(&store, "tinywasm_doom_wad_path_buf")?;
        let init = instance.func::<(), ()>(&store, "tinywasm_doom_init")?;
        let update = instance.func::<(), ()>(&store, "tinywasm_doom_update")?;
        let framebuffer = instance.func::<(), i32>(&store, "tinywasm_doom_framebuffer")?;
        let key_down = instance.func::<i32, ()>(&store, "tinywasm_doom_key_down")?;
        let key_up = instance.func::<i32, ()>(&store, "tinywasm_doom_key_up")?;
        let memory = instance.memory("memory")?;

        let buf_ptr = wad_path_buf.call(&mut store, ())? as usize;
        let wad_path_string = host_state.borrow().wad_path.to_string_lossy().into_owned();
        memory.write_cstring_bytes(&mut store, buf_ptr, &wad_path_string)?;
        init.call(&mut store, ())?;

        let width = SCREEN_WIDTH;
        let height = SCREEN_HEIGHT;

        Ok(Self {
            store,
            update,
            framebuffer,
            key_down,
            key_up,
            memory,
            framebuffer_bytes: vec![0; width * height * 4],
            host_state,
        })
    }

    pub fn tick(&mut self) -> Result<()> {
        self.update.call(&mut self.store, ())?;
        Ok(())
    }

    pub fn write_framebuffer(&mut self, dst: &mut [u32]) -> Result<()> {
        let ptr = self.framebuffer.call(&mut self.store, ())? as usize;
        self.memory.read_exact(&self.store, ptr, &mut self.framebuffer_bytes)?;
        for (index, pixel) in dst.iter_mut().enumerate() {
            let byte_index = index * 4;
            let chunk = &self.framebuffer_bytes[byte_index..byte_index + 4];
            *pixel = ((chunk[0] as u32) << 16) | ((chunk[1] as u32) << 8) | chunk[2] as u32;
        }
        Ok(())
    }

    pub fn key_down(&mut self, key: i32) -> Result<()> {
        self.key_down.call(&mut self.store, key)?;
        Ok(())
    }

    pub fn key_up(&mut self, key: i32) -> Result<()> {
        self.key_up.call(&mut self.store, key)?;
        Ok(())
    }
}

pub struct HostState {
    pub wad_path: PathBuf,
    runtime_dir: PathBuf,
    start: Instant,
    files: BTreeMap<i32, File>,
    next_file: i32,
    pub exit_code: Option<i32>,
}

impl HostState {
    fn new(wad_path: PathBuf) -> Self {
        let runtime_dir = PathBuf::from("examples/doom/out/runtime");
        let _ = create_dir_all(&runtime_dir);
        Self { wad_path, runtime_dir, start: Instant::now(), files: BTreeMap::new(), next_file: 3, exit_code: None }
    }

    fn resolve_path(&self, path: &str) -> PathBuf {
        let candidate = Path::new(path);
        if candidate.is_absolute() { candidate.to_path_buf() } else { self.runtime_dir.join(candidate) }
    }

    fn should_redirect_to_wad(&self, requested: &str) -> bool {
        let Some(file_name) = Path::new(requested).file_name().and_then(|name| name.to_str()) else {
            return false;
        };

        let requested = file_name.to_ascii_lowercase();
        let provided = self.wad_path.file_name().and_then(|name| name.to_str()).map(|name| name.to_ascii_lowercase());

        match provided.as_deref() {
            Some("doom1.wad") => requested == "doom1.wad",
            Some("doom.wad") => requested == "doom.wad",
            Some("doomu.wad") => requested == "doomu.wad",
            Some("doom2.wad") => requested == "doom2.wad",
            Some("doom2f.wad") => requested == "doom2f.wad",
            Some("plutonia.wad") => requested == "plutonia.wad",
            Some("tnt.wad") => requested == "tnt.wad",
            Some(provided_name) => requested == provided_name,
            None => false,
        }
    }

    fn open_mode_options(mode: &str) -> OpenOptions {
        let mut options = OpenOptions::new();
        let plus = mode.as_bytes().contains(&b'+');

        match mode.as_bytes().first().copied() {
            Some(b'r') => {
                options.read(true);
                if plus {
                    options.write(true);
                }
            }
            Some(b'w') => {
                options.write(true).create(true).truncate(true);
                if plus {
                    options.read(true);
                }
            }
            Some(b'a') => {
                options.write(true).create(true).append(true);
                if plus {
                    options.read(true);
                }
            }
            _ => {
                options.read(true);
            }
        }

        options
    }
}

fn build_imports(store: &mut Store, state: Rc<RefCell<HostState>>) -> Imports {
    let mut imports = Imports::new();

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_open",
            HostFunction::from(store, move |ctx: FuncContext<'_>, (filename_ptr, mode_ptr): (i32, i32)| {
                let memory = ctx.memory("memory")?;
                let filename = memory.read_cstring_until_null(ctx.store(), filename_ptr as usize, 1024)?;
                let mode = memory.read_cstring_until_null(ctx.store(), mode_ptr as usize, 16)?;
                let filename = filename.to_string_lossy();
                let mode = mode.to_string_lossy();
                let mut state = state.borrow_mut();
                let path = if filename == state.wad_path.to_string_lossy() || state.should_redirect_to_wad(&filename) {
                    state.wad_path.clone()
                } else {
                    state.resolve_path(&filename)
                };

                if path.is_dir() {
                    log::debug!("guest open rejected directory: path={} mode={}", path.display(), mode);
                    return Ok(-1);
                }

                let file = match HostState::open_mode_options(&mode).open(&path) {
                    Ok(file) => file,
                    Err(err) => {
                        log::debug!("guest open failed: path={} mode={} err={err}", path.display(), mode);
                        return Ok(-1);
                    }
                };

                let handle = state.next_file;
                state.next_file += 1;
                state.files.insert(handle, file);
                Ok(handle)
            }),
        );
    }

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_close",
            HostFunction::from(store, move |_ctx: FuncContext<'_>, handle: i32| {
                state.borrow_mut().files.remove(&handle);
                Ok(())
            }),
        );
    }

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_read",
            HostFunction::from(store, move |mut ctx: FuncContext<'_>, (handle, buf_ptr, count): (i32, i32, i32)| {
                let mut state = state.borrow_mut();
                let Some(file) = state.files.get_mut(&handle) else {
                    return Ok(0);
                };
                let mut buffer = vec![0; count.max(0) as usize];
                let read = file.read(&mut buffer).map_err(|err| tinywasm::Error::Other(err.to_string()))?;
                ctx.memory("memory")?.copy_from_slice(ctx.store_mut(), buf_ptr as usize, &buffer[..read])?;
                Ok(read as i32)
            }),
        );
    }

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_write",
            HostFunction::from(store, move |ctx: FuncContext<'_>, (handle, buf_ptr, count): (i32, i32, i32)| {
                let data = ctx.memory("memory")?.read_vec(ctx.store(), buf_ptr as usize, count.max(0) as usize)?;
                let mut state = state.borrow_mut();
                let Some(file) = state.files.get_mut(&handle) else {
                    return Ok(-1);
                };
                let written = file.write(&data).map_err(|err| tinywasm::Error::Other(err.to_string()))?;
                Ok(written as i32)
            }),
        );
    }

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_seek",
            HostFunction::from(store, move |_ctx: FuncContext<'_>, (handle, offset, origin): (i32, i32, i32)| {
                let seek_from = match origin {
                    0 => SeekFrom::Start(offset.max(0) as u64),
                    1 => SeekFrom::Current(offset as i64),
                    2 => SeekFrom::End(offset as i64),
                    _ => return Err(tinywasm::Error::Other(format!("invalid seek origin: {origin}"))),
                };
                let mut state = state.borrow_mut();
                let Some(file) = state.files.get_mut(&handle) else {
                    return Ok(-1);
                };
                let pos = file.seek(seek_from).map_err(|err| tinywasm::Error::Other(err.to_string()))?;
                Ok(pos.min(i32::MAX as u64) as i32)
            }),
        );
    }

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_tell",
            HostFunction::from(store, move |_ctx: FuncContext<'_>, handle: i32| {
                let mut state = state.borrow_mut();
                let Some(file) = state.files.get_mut(&handle) else {
                    return Ok(-1);
                };
                let pos = file.stream_position().map_err(|err| tinywasm::Error::Other(err.to_string()))?;
                Ok(pos.min(i32::MAX as u64) as i32)
            }),
        );
    }

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_eof",
            HostFunction::from(store, move |_ctx: FuncContext<'_>, handle: i32| {
                let mut state = state.borrow_mut();
                let Some(file) = state.files.get_mut(&handle) else {
                    return Ok(1);
                };
                let pos = file.stream_position().map_err(|err| tinywasm::Error::Other(err.to_string()))?;
                let len = file.metadata().map_err(|err| tinywasm::Error::Other(err.to_string()))?.len();
                Ok((pos >= len) as i32)
            }),
        );
    }

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_gettime",
            HostFunction::from(store, move |mut ctx: FuncContext<'_>, (sec_ptr, usec_ptr): (i32, i32)| {
                let elapsed = state.borrow().start.elapsed();
                let sec = elapsed.as_secs().min(i32::MAX as u64) as i32;
                let usec = elapsed.subsec_micros() as i32;
                let memory = ctx.memory("memory")?;
                memory.copy_from_slice(ctx.store_mut(), sec_ptr as usize, &sec.to_le_bytes())?;
                memory.copy_from_slice(ctx.store_mut(), usec_ptr as usize, &usec.to_le_bytes())?;
                Ok(())
            }),
        );
    }

    {
        let state = state.clone();
        imports.define(
            IMPORT_MODULE,
            "host_exit",
            HostFunction::from(store, move |_ctx: FuncContext<'_>, code: i32| {
                state.borrow_mut().exit_code = Some(code);
                Ok(())
            }),
        );
    }

    imports.define(
        IMPORT_MODULE,
        "host_print",
        HostFunction::from(store, move |ctx: FuncContext<'_>, ptr: i32| {
            let text = ctx.memory("memory")?.read_cstring_until_null(ctx.store(), ptr as usize, 4096)?;
            log::info!("guest: {}", text.to_string_lossy());
            Ok(())
        }),
    );

    imports
}