use std::{
    collections::{hash_map, HashMap},
    ops::Range,
};

use bstr::ByteVec;

use crate::{extension, State, Version};

impl State {
    pub fn write_to(&self, options: Options) -> Vec<u8> {
        let mut writer = Writer::new(self, options);
        writer.generate();
        writer.data
    }
}

#[derive(Default)]
pub struct Options {
    hash_kind: git_hash::Kind,
}

struct Writer<'a> {
    state: &'a State,
    options: Options,
    data: Vec<u8>,
    index_table: HashMap<&'static str, Range<usize>>,
}

impl<'a> Writer<'a> {
    pub fn new(state: &'a State, options: Options) -> Self {
        Self {
            state,
            options,
            data: Vec::default(),
            index_table: Default::default(),
        }
    }

    pub fn generate(&mut self) {
        self.header();
        self.entries();

        // TODO: Tree extension is always included, I think
        if let Some(t) = self.state.tree() {
            self.tree(t)
        }

        self.end_of_index();
    }

    fn push(&mut self, data: &[u8], key: &'static str) {
        let start = self.data.len();
        let end = start + data.len();

        match self.index_table.entry(key) {
            hash_map::Entry::Occupied(mut e) => e.get_mut().end = end,
            hash_map::Entry::Vacant(e) => {
                e.insert(start..end);
            }
        };

        self.data.push_str(data);
    }

    fn header(&mut self) {
        let signature = b"DIRC";
        let version = match self.state.version() {
            Version::V2 => 2_u32.to_be_bytes(),
            Version::V3 => 3_u32.to_be_bytes(),
            Version::V4 => 4_u32.to_be_bytes(),
        };
        let num_entries = self.state.entries().len() as u32;

        self.push(signature, "header");
        self.push(&version, "header");
        self.push(&(num_entries).to_be_bytes(), "header");
    }

    fn entries(&mut self) {
        for e in self.state.entries() {
            self.push(&e.stat.ctime.secs.to_be_bytes(), "entries");
            self.push(&e.stat.ctime.nsecs.to_be_bytes(), "entries");
            self.push(&e.stat.mtime.secs.to_be_bytes(), "entries");
            self.push(&e.stat.mtime.nsecs.to_be_bytes(), "entries");
            self.push(&e.stat.dev.to_be_bytes(), "entries");
            self.push(&e.stat.ino.to_be_bytes(), "entries");
            self.push(&e.mode.bits().to_be_bytes(), "entries");
            self.push(&e.stat.uid.to_be_bytes(), "entries");
            self.push(&e.stat.gid.to_be_bytes(), "entries");
            self.push(&e.stat.size.to_be_bytes(), "entries");
            self.push(e.id.as_bytes(), "entries");
            //FIXME: correct flag values
            // probably convert 'in-memory' Flags to at_rest::Flags
            // self.push(&e.flags.bits().to_be_bytes(), "entries");
            self.push(b"\x00\x01\x61\x00", "entries");

            println!("{:?}", e.flags.bits());
        }
    }

    fn tree(&mut self, tree: &extension::Tree) {
        let signature = b"TREE";
        let mut size: u32 = 0;

        self.push(signature, "tree");
        self.push(&size.to_be_bytes(), "tree");

        self.tree_entry(tree);

        if let Some(range) = self.index_table.get("tree") {
            size = (range.end - (range.start + 8)) as u32;
            self.data[range.start + 4..range.start + 8].copy_from_slice(&size.to_be_bytes());
        }
    }

    fn tree_entry(&mut self, tree: &extension::Tree) {
        let path = [tree.name.as_slice(), b"\0"].concat();

        let num_entries_ascii = tree.num_entries.to_string();
        let num_children_ascii = tree.children.len().to_string();

        self.push(path.as_slice(), "tree");
        self.push(num_entries_ascii.as_bytes(), "tree");
        self.push(b" ", "tree");
        self.push(num_children_ascii.as_bytes(), "tree");
        self.push(b"\n", "tree");
        self.push(tree.id.as_bytes(), "tree");

        for child in &tree.children {
            self.tree_entry(child);
        }
    }

    fn end_of_index(&mut self) {
        match self.index_table.get("entries") {
            Some(range) => {
                let signature = b"EOIE";
                let extension_size = 4 + self.options.hash_kind.len_in_bytes() as u32;
                let offset: u32 = range.end as u32;

                let mut hasher = git_features::hash::hasher(self.options.hash_kind);

                match self.index_table.get("tree") {
                    Some(range) => {
                        hasher.update(b"TREE");
                        hasher.update(&self.data[range.start + 4..range.start + 8]);
                    }
                    None => {}
                }

                let hash = hasher.digest();

                self.data.push_str(signature);
                self.data.push_str(extension_size.to_be_bytes());
                self.data.push_str(offset.to_be_bytes());
                self.data.push_str(hash);
            }
            None => {}
        }
    }
}