use crate::{CompressedSchema, Number, Schema, SchemaValue, ToNode};
use anchor_lang::{prelude::*, solana_program::keccak};
use spl_account_compression::Node;
use std::collections::HashMap;

impl ToNode for u8 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for u8 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::U64(self.clone().into()))
    }
}

impl ToNode for u16 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for u16 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::U64(self.clone().into()))
    }
}

impl ToNode for u32 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for u32 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::U64(self.clone().into()))
    }
}

impl ToNode for u64 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for u64 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::U64(self.clone()))
    }
}

impl ToNode for i8 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for i8 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::I64(self.clone().into()))
    }
}

impl ToNode for i16 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for i16 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::I64(self.clone().into()))
    }
}

impl ToNode for i32 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for i32 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::I64(self.clone().into()))
    }
}

impl ToNode for i64 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for i64 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::I64(self.clone()))
    }
}

impl ToNode for f32 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for f32 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::F64(self.clone().into()))
    }
}

impl ToNode for f64 {
    fn to_node(&self) -> Node {
        let bytes = self.clone().to_le_bytes();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for f64 {
    fn schema() -> Schema {
        Schema::Number
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Number(Number::F64(self.clone()))
    }
}

impl ToNode for String {
    fn to_node(&self) -> Node {
        keccak::hashv(&[self.clone().as_bytes()][..]).to_bytes()
    }
}

impl CompressedSchema for String {
    fn schema() -> Schema {
        Schema::String
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::String(self.clone())
    }
}

impl<T: ToNode> ToNode for Vec<T> {
    fn to_node(&self) -> Node {
        let mut seeds: Vec<[u8; 32]> = vec![];
        for item in self {
            let node = item.to_node();
            seeds.push(node);
        }
        let seeds_refs: Vec<&[u8]> = seeds.iter().map(|node| &node[..]).collect();
        keccak::hashv(&seeds_refs[..]).to_bytes()
    }
}

impl<T: CompressedSchema> CompressedSchema for Vec<T> {
    fn schema() -> Schema {
        Schema::Array(Box::new(T::schema()))
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Array(self.iter().map(|i| i.schema_value()).collect())
    }
}

impl ToNode for Pubkey {
    fn to_node(&self) -> Node {
        self.to_bytes()
    }
}

impl CompressedSchema for Pubkey {
    fn schema() -> Schema {
        Schema::Pubkey
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Pubkey(self.clone())
    }
}

impl ToNode for bool {
    fn to_node(&self) -> Node {
        let bytes = self.clone().try_to_vec().unwrap();
        keccak::hashv(&[bytes.as_ref()][..]).to_bytes()
    }
}

impl CompressedSchema for bool {
    fn schema() -> Schema {
        Schema::Bool
    }

    fn schema_value(&self) -> SchemaValue {
        SchemaValue::Bool(self.clone())
    }
}

impl<T: ToNode> ToNode for Option<T> {
    fn to_node(&self) -> Node {
        match self {
            Some(value) => value.to_node(),
            None => keccak::hashv(&[&[0u8][..]][..]).to_bytes(),
        }
    }
}

impl<T: CompressedSchema> CompressedSchema for Option<T> {
    fn schema() -> Schema {
        Schema::Option(Box::new(T::schema()))
    }

    fn schema_value(&self) -> SchemaValue {
        if self.is_some() {
            self.as_ref().unwrap().schema_value()
        } else {
            SchemaValue::Null
        }
    }
}

impl<V: ToNode> ToNode for HashMap<String, V> {
    fn to_node(&self) -> Node {
        let mut seeds: Vec<[u8; 32]> = vec![];
        for (key, value) in self {
            let key_node = key.to_node();
            let value_node = value.to_node();
            seeds.push(keccak::hashv(&[&key_node[..]][..]).to_bytes());
            seeds.push(keccak::hashv(&[&value_node[..]][..]).to_bytes());
        }
        let seeds_refs: Vec<&[u8]> = seeds.iter().map(|node| &node[..]).collect();
        keccak::hashv(&seeds_refs[..]).to_bytes()
    }
}

impl<K: ToString, V: CompressedSchema> CompressedSchema for HashMap<K, V> {
    fn schema() -> Schema {
        Schema::HashMap(Box::new(Schema::String), Box::new(V::schema()))
    }

    fn schema_value(&self) -> SchemaValue {
        let mut schema = HashMap::new();
        self.iter().for_each(|(key, value)| {
            schema.insert(key.to_string(), value.schema_value());
        });
        SchemaValue::HashMap(schema)
    }
}