use super::data_type::{decode_field_for_data_type, DataType, DataTypeDecodeError};
use crate::record::{Record, Value};
use minicbor::{
    data::{Tag, Type},
    decode::Probe,
    Decoder,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use thiserror::Error;
use uuid::Uuid;

/// The SchemaField enum combines both the primitive data types with a "nested" type that indicates
/// a nested map in the schema.
///
/// The type is separate from [`DataType`] to support Serde's untagged unions.
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
#[serde(untagged)]
pub enum SchemaField {
    DataType(DataType),
    Nested(HashMap<String, SchemaField>),
}

impl From<DataType> for SchemaField {
    fn from(t: DataType) -> Self {
        Self::DataType(t)
    }
}

impl SchemaField {
    /// Indicate that a certain type can't be decoded in to the current SchemaField
    fn as_decode_not_supported<V>(&self, from: Type) -> Result<V, RecordDecoderError> {
        Err(RecordDecoderError::DecodeNotSupported {
            from,
            to: self.clone(),
        })
    }
}

#[derive(Error, Debug)]
pub enum RecordDecoderError {
    #[error("{0}")]
    CborDecode(minicbor::decode::Error),
    #[error("Type {from} cannot be decoded into {:?}", .to)]
    DecodeNotSupported { from: Type, to: SchemaField },
    #[error("Failed to decode field: {0}")]
    FieldDecode(#[from] DataTypeDecodeError),
    #[error("Unable to parse ID '{0}'")]
    InvalidID(String),
    #[error("{0}")]
    Other(String),
}

impl From<minicbor::decode::Error> for RecordDecoderError {
    fn from(val: minicbor::decode::Error) -> Self {
        Self::CborDecode(val)
    }
}

/// The RecordSchema is the `types` section of CipherStash's [collection schema].
/// It indicates the correct shape for records that are stored in CipherStash.
///
/// [collection schema]: https://docs.cipherstash.com/reference/schema-definition.html
#[derive(Debug, Serialize, Deserialize)]
pub struct RecordSchema {
    #[serde(flatten)]
    pub map: HashMap<String, SchemaField>,
}

impl RecordSchema {
    /// Get a specific schema field from the [`RecordSchema`]
    pub fn get(&self, key: &str) -> Option<&SchemaField> {
        self.map.get(key)
    }
}

/// A RecordDecoder can decode a record from a CBOR byte buffer based on the supplied schema.
///
/// Because not all languages have every datatype, it will perform a best-effort conversion from
/// the values inside the CBOR payload into the expected values, bailing whenever a conversion is impossible.
#[derive(Debug)]
pub struct RecordDecoder {
    pub(crate) schema: RecordSchema,
}

/// Iterate through a Minicbor map and decode the value at the current position.
///
/// The callback passed to this method must decode a value or call `skip` otherwise the map won't
/// be parsed correctly.
fn decoder_map_iter(
    d: &mut Decoder,
    mut callback: impl FnMut(&mut Decoder, &str) -> Result<(), RecordDecoderError>,
) -> Result<(), RecordDecoderError> {
    let mut len = d.map()?;

    loop {
        if let Some(0) = len {
            break;
        }

        if let Type::Break = d.datatype()? {
            d.skip()?;
            break;
        }

        len = len.map(|x| x - 1);

        if let Type::String = d.datatype()? {
            let key = d.str()?;
            callback(d, key)?;
        } else {
            // If the current type wasn't a string then the map has non-string keys.
            // In this case, just consume the current item and continue the loop.
            //
            // Skip the key:
            d.skip()?;
            // Skip the value:
            d.skip()?;
        }
    }

    Ok(())
}

impl RecordDecoder {
    /// Decode a map based on a schema from a CBOR decoder.
    ///
    /// Only call this method when the next item in the CBOR decoder is a map. Calling this when
    /// that isn't the case will return Err.
    fn decode_map_for_schema(
        schema: &HashMap<String, SchemaField>,
        d: &mut Decoder,
    ) -> Result<HashMap<String, Value>, RecordDecoderError> {
        let mut output = HashMap::new();

        decoder_map_iter(d, |d, key| {
            let key = String::from(key);

            if let Some(expected) = schema.get(&key) {
                if let Some(value) = Self::decode_for_field_type(expected, d)? {
                    output.insert(key, value);
                }
            } else {
                match d.datatype()? {
                    Type::String => {
                        // If the value wasn't in the schema, but was a string - include it anyway.
                        // This is to support field dynamic match and dynamic match since they include all
                        // string fields in the record.
                        output.insert(key, Value::String(d.str()?.into()));
                    }
                    Type::Map | Type::MapIndef => {
                        let empty_schema = HashMap::with_capacity(0);
                        // If there is a nested map that wasn't specified in the schema, traverse
                        // it to look for strings. As mentioned above, strings need to be included
                        // regardless of the schema to support (field) dynamic match.
                        output.insert(
                            key,
                            Value::Map(Self::decode_map_for_schema(&empty_schema, d)?),
                        );
                    }
                    _ => {
                        // If the value isn't inside the schema and isn't a string, don't bother trying to decode it.
                        d.skip()?;
                    }
                }
            }

            Ok(())
        })?;

        Ok(output)
    }

    fn decode_for_field_type(
        field_type: &SchemaField,
        d: &mut Decoder,
    ) -> Result<Option<Value>, RecordDecoderError> {
        // It's common in languages like JavaScript to set values to `null` or `undefined` rather than
        // omitting them. Just ignore these fields.
        if let Type::Null | Type::Undefined = d.datatype()? {
            d.skip()?;
            return Ok(None);
        }

        Ok(Some(match field_type {
            SchemaField::DataType(data_type) => decode_field_for_data_type(data_type, d)?,
            SchemaField::Nested(schema) => Value::Map(match d.datatype()? {
                Type::Map | Type::MapIndef => Self::decode_map_for_schema(schema, d)?,
                t => {
                    return field_type.as_decode_not_supported(t);
                }
            }),
        }))
    }

    /// Consume a decoder probe to extract the records id
    ///
    /// If the record doesn't have an id this method will return an error
    fn extract_id_from_probe(mut probe: Probe) -> Result<Uuid, RecordDecoderError> {
        let mut result: Option<[u8; 16]> = None;

        decoder_map_iter(&mut probe, |d, key| {
            if key == "id" {
                match d.datatype()? {
                    Type::Tag => {
                        match d.tag()? {
                            // Uint8Array (see https://www.npmjs.com/package/cbor)
                            Tag::Unassigned(64) => result.replace(
                                d.bytes()
                                    .map_err(|e| RecordDecoderError::InvalidID(format!("{}", e)))?
                                    .try_into()
                                    .map_err(|_| {
                                        RecordDecoderError::Other("ID Vector too large".into())
                                    })?,
                            ),
                            t => {
                                return Err(RecordDecoderError::Other(format!(
                                    "Unsupported ID tag type: {:?}",
                                    t
                                )))
                            }
                        }
                    }
                    Type::Array => result.replace(
                        d.array_iter::<u8>()?
                            .collect::<Result<Vec<u8>, _>>()
                            .map_err(|e| RecordDecoderError::InvalidID(e.to_string()))?
                            .as_slice()
                            .try_into()
                            .map_err(|e| {
                                RecordDecoderError::InvalidID(format!(
                                    "Array does not fit into uuid: {}",
                                    e
                                ))
                            })?,
                    ),
                    Type::Bytes => result.replace(
                        d.bytes()
                            .map_err(|e| RecordDecoderError::InvalidID(format!("{}", e)))?
                            .try_into()
                            .map_err(|e| {
                                RecordDecoderError::InvalidID(format!(
                                    "Byte buffer does not fit into uuid: {}",
                                    e
                                ))
                            })?,
                    ),
                    t => {
                        return Err(RecordDecoderError::InvalidID(format!(
                            "Unsupported id encoding: {}",
                            t
                        )))
                    }
                };
            } else {
                d.skip()?;
            }

            Ok(())
        })?;

        result
            .ok_or_else(|| RecordDecoderError::Other("Could not find id in top level map".into()))
            .map(Uuid::from_bytes)
    }

    /// Try and decode the provided bytes into a Record, based on the RecordDecoder's schema.
    pub fn decode(&self, bytes: &[u8]) -> Result<Record, RecordDecoderError> {
        let mut decoder = Decoder::new(bytes);

        let id = Self::extract_id_from_probe(decoder.probe())?;
        let fields = Self::decode_map_for_schema(&self.schema.map, &mut decoder)?;

        Ok(Record { id, fields })
    }
}

#[cfg(test)]
mod tests {
    use super::{DataType, RecordDecoder, Value};
    use ciborium::cbor;
    use ciborium::de::from_reader;

    use crate::{
        decoder::{RecordSchema, SchemaField},
        utils::{cbor_buffer, collection, record},
    };

    use serde_bytes::ByteBuf;

    fn generate_id() -> ByteBuf {
        ByteBuf::from([0; 16])
    }

    #[test]
    fn test_simple_decode_record() {
        let test_buffer = cbor_buffer!({
            "id" => generate_id(),
            "title" => "Great Movie",
            "runningTime" => 160,
            "year" => 1960
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "title" => SchemaField::DataType(DataType::String),
                    "runningTime" => SchemaField::DataType(DataType::Float64),
                    "year" => SchemaField::DataType(DataType::Uint64)
                },
            },
        };

        let record = decoder
            .decode(&test_buffer)
            .expect("Failed to decode record");

        assert_eq!(
            record.get("title"),
            Some(&Value::String(String::from("Great Movie")))
        );

        assert_eq!(record.get("runningTime"), Some(&Value::Float64(160.)));

        assert_eq!(record.get("year"), Some(&Value::Uint64(1960)));
    }

    #[test]
    fn test_skip_irrelevant_schema() {
        let test_buffer = cbor_buffer!({
            "id" => generate_id(),
            "title" => "Great Movie",
            "runningTime" => 160,
            "unused" => {
                "another" => 1000,
                "field" => "wow"
            },
            "year" => 1960,
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "title" => SchemaField::DataType(DataType::String),
                    "runningTime" => SchemaField::DataType(DataType::Float64),
                    "year" => SchemaField::DataType(DataType::Uint64),

                },
            },
        };

        let record = decoder
            .decode(&test_buffer)
            .expect("Failed to decode record");

        assert_eq!(
            record.get("title"),
            Some(&Value::String(String::from("Great Movie")))
        );

        assert_eq!(record.get("runningTime"), Some(&Value::Float64(160.)));

        assert_eq!(record.get("year"), Some(&Value::Uint64(1960)));

        assert_eq!(
            record.get("unused"),
            Some(&Value::Map(collection! {
                "field" => "wow"
            }))
        );
    }

    #[test]
    fn test_passes_on_missing_field() {
        let test_buffer = cbor_buffer!({

            "id" => generate_id(),
        "title" => "Great Movie",
            });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "title" => SchemaField::DataType(DataType::String),
                    "runningTime" => SchemaField::DataType(DataType::Float64),
                    "year" => SchemaField::DataType(DataType::Uint64)
                },
            },
        };

        let record = decoder
            .decode(&test_buffer)
            .expect("Failed to decode record");

        assert_eq!(
            record.get("title"),
            Some(&Value::String(String::from("Great Movie")))
        );

        assert_eq!(record.get("runningTime"), None);

        assert_eq!(record.get("year"), None);
    }

    #[test]
    fn test_convert_float_to_int() {
        let test_buffer = cbor_buffer!({
            "id" => generate_id(),
            "float_val" => 10_f32,
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "float_val" => SchemaField::DataType(DataType::Uint64)
                },
            },
        };

        let record = decoder
            .decode(&test_buffer)
            .expect("Failed to decode buffer");

        assert_eq!(record.get("float_val"), Some(&Value::Uint64(10)));
    }

    #[test]
    fn test_convert_large_int_to_float() {
        let test_buffer = cbor_buffer!({
            "id" => generate_id(),
            "float_val" => u64::MAX,
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "float_val" => SchemaField::DataType(DataType::Float64)
                },
            },
        };

        let err = decoder
            .decode(&test_buffer)
            .expect_err("Conversion should fail");

        assert_eq!(
            err.to_string(),
            "Failed to decode field: Conversion failed: conversion resulted in positive overflow"
        );
    }

    #[test]
    fn test_convert_large_float_to_int() {
        let test_buffer = cbor_buffer!({
            "id" => generate_id(),
            "float_val" => 1000000000000000000000_f64,
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "float_val" => SchemaField::DataType(DataType::Uint64)
                },
            },
        };

        let err = decoder
            .decode(&test_buffer)
            .expect_err("Conversion should fail");

        assert_eq!(
            err.to_string(),
            "Failed to decode field: Conversion failed: f64 doesn\'t correctly fit into u64"
        );
    }

    #[test]
    fn test_convert_fract_to_int() {
        let test_buffer = cbor_buffer!({
            "id" => generate_id(),
            "float_val" => 10.5,
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "float_val" => SchemaField::DataType(DataType::Uint64)
                },
            },
        };

        let err = decoder
            .decode(&test_buffer)
            .expect_err("Conversion should fail");

        assert_eq!(
            err.to_string(),
            "Failed to decode field: Conversion failed: f64 doesn\'t correctly fit into u64"
        );
    }

    #[test]
    fn test_convert_negative_int_to_uint() {
        let test_buffer = cbor_buffer!({
            "id" => generate_id(),
            "int_val" => -1000,
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "int_val" => SchemaField::DataType(DataType::Uint64)
                },
            },
        };

        let err = decoder
            .decode(&test_buffer)
            .expect_err("Conversion should fail");

        assert_eq!(
            err.to_string(),
            "Failed to decode field: Conversion failed: conversion resulted in negative overflow"
        );
    }

    #[test]
    fn test_convert_f16_to_float() {
        let mut test_buffer = vec![];

        let mut encoder = minicbor::Encoder::new(&mut test_buffer);

        encoder
            .map(2)
            .unwrap()
            .str("float_val")
            .unwrap()
            .f16(10.)
            .unwrap()
            .str("id")
            .unwrap()
            .bytes(&[0; 16])
            .unwrap();

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "float_val" => SchemaField::DataType(DataType::Float64)
                },
            },
        };

        let val = decoder
            .decode(&test_buffer)
            .expect("Failed to decode record");

        assert_eq!(val.get("float_val"), Some(&Value::Float64(10.)));
    }

    #[test]
    fn test_non_string_keys() {
        let test_buffer = cbor_buffer!({
            "id" => generate_id(),
            10_f32 => "float",
            10_u32 => "int",
            false => "bool",
            "string" => "string",
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "string" => SchemaField::DataType(DataType::String)
                },
            },
        };

        let record = decoder
            .decode(&test_buffer)
            .expect("Failed to decode buffer");

        assert_eq!(record.get("string"), Some(&Value::String("string".into())));
    }

    #[test]
    fn test_include_non_specified_strings() {
        let id = generate_id();

        let test_buffer = cbor_buffer!({
            "id" => &id,
            "expected" => "first",
            "unexpected" => "second",
            "nested" => {
                "unexpected" => "third",
            }
        });

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "expected" => SchemaField::DataType(DataType::String)
                },
            },
        };

        let record = decoder
            .decode(&test_buffer)
            .expect("Failed to decode buffer");

        assert_eq!(
            record,
            record! {
                "id" => uuid::Uuid::from_bytes(id.as_slice().try_into().unwrap()),
                "expected" => "first",
                "unexpected" => "second",
                "nested" => collection! {
                    "unexpected" => "third"
                }
            }
        );
    }

    #[test]
    fn test_decode_null() {
        let mut test_buffer = vec![];

        let mut encoder = minicbor::Encoder::new(&mut test_buffer);

        encoder
            .map(3)
            .unwrap()
            .str("null")
            .unwrap()
            .null()
            .unwrap()
            .str("undefined")
            .unwrap()
            .undefined()
            .unwrap()
            .str("id")
            .unwrap()
            .bytes(&[0; 16])
            .unwrap();

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "null" => SchemaField::DataType(DataType::Float64),
                    "undefined" => SchemaField::DataType(DataType::Float64)
                },
            },
        };

        let val = decoder
            .decode(&test_buffer)
            .expect("Failed to decode record");

        assert_eq!(val.get("null"), None);
        assert_eq!(val.get("undefined"), None);
    }

    #[test]
    fn test_decode_indef_map() {
        let mut test_buffer = vec![];

        let mut encoder = minicbor::Encoder::new(&mut test_buffer);

        encoder
            .begin_map()
            .unwrap()
            .str("first")
            .unwrap()
            .str("a")
            .unwrap()
            .str("second")
            .unwrap()
            .str("b")
            .unwrap()
            .str("id")
            .unwrap()
            .bytes(&[0; 16])
            .unwrap()
            .end()
            .unwrap();

        let decoder = RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "first" => SchemaField::DataType(DataType::String),
                    "second" => SchemaField::DataType(DataType::String)
                },
            },
        };

        let val = decoder
            .decode(&test_buffer)
            .expect("Failed to decode record");

        assert_eq!(val.get("first"), Some(&Value::String("a".into())));
        assert_eq!(val.get("second"), Some(&Value::String("b".into())));
    }

    fn create_date_decoder() -> RecordDecoder {
        RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "date" => SchemaField::DataType(DataType::Date)
                },
            },
        }
    }

    fn create_bigint_decoder() -> RecordDecoder {
        RecordDecoder {
            schema: RecordSchema {
                map: collection! {
                    "bigint" => SchemaField::DataType(DataType::Uint64)
                },
            },
        }
    }

    #[test]
    fn test_decode_js_date() {
        // JS: { id: ArrayBuffer(16), date: new Date(2022, 0) }
        let buf =
            hex_literal::hex!("a262696450000000000000000000000000000000006464617465c11a61cdbb60");

        let decoder = create_date_decoder();

        let val = decoder.decode(&buf).unwrap();

        assert_eq!(
            val.get("date"),
            Some(&Value::date_from_millis(1640872800000))
        );
    }

    #[test]
    fn test_decode_js_date_float() {
        // JS: { id: ArrayBuffer(16), date: new Date(2022, 0, 0, 0, 0, 0, 100) }
        let buf = hex_literal::hex!(
            "a262696450000000000000000000000000000000006464617465c1fb41d8736ed8066666"
        );

        let decoder = create_date_decoder();

        let val = decoder.decode(&buf).unwrap();

        assert_eq!(
            val.get("date"),
            Some(&Value::date_from_millis(1640872800100))
        );
    }

    #[test]
    fn test_decode_js_date_neg_float() {
        // JS: { id: ArrayBuffer(16), date: new Date(0, 0, 0, 0, 0, 0, 1) }
        let buf = hex_literal::hex!(
            "a262696450000000000000000000000000000000006464617465c1fbc1e0758b93fff7cf"
        );

        let decoder = create_date_decoder();

        let val = decoder.decode(&buf).unwrap();

        assert_eq!(
            val.get("date"),
            Some(&Value::date_from_millis(-2209111199999))
        );
    }

    #[test]
    fn test_decode_js_date_neg_int() {
        // JS: { id: ArrayBuffer(16), date: new Date(0, 0, 0, 0, 0, 0, 0) }
        let buf =
            hex_literal::hex!("a262696450000000000000000000000000000000006464617465c13a83ac5c9f");

        let decoder = create_date_decoder();

        let val = decoder.decode(&buf).unwrap();

        assert_eq!(
            val.get("date"),
            Some(&Value::date_from_millis(-2209111200000))
        );
    }

    #[test]
    fn test_decode_js_bignum() {
        // JS: { id: ArrayBuffer(16), bigint: 123n }
        let buf =
            hex_literal::hex!("a2626964500000000000000000000000000000000066626967696e74c2417b");

        let decoder = create_bigint_decoder();

        let val = decoder.decode(&buf).unwrap();

        assert_eq!(val.get("bigint"), Some(&Value::Uint64(123)));
    }

    #[test]
    fn test_decode_schema() {
        let buffer = cbor_buffer!({
            "int" => "uint64",
            "float" => "float64",
            "str" => "string",
            "bool" => "boolean",
            "date" => "date",
            "nested" => { "test" => "uint64" }
        });

        let schema: RecordSchema = from_reader(&buffer[..]).expect("Failed to decode");

        assert_eq!(
            schema.get("int").unwrap(),
            &SchemaField::DataType(DataType::Uint64)
        );
        assert_eq!(
            schema.get("float").unwrap(),
            &SchemaField::DataType(DataType::Float64)
        );
        assert_eq!(
            schema.get("str").unwrap(),
            &SchemaField::DataType(DataType::String)
        );
        assert_eq!(
            schema.get("bool").unwrap(),
            &SchemaField::DataType(DataType::Boolean)
        );
        assert_eq!(
            schema.get("date").unwrap(),
            &SchemaField::DataType(DataType::Date)
        );
        assert_eq!(
            schema.get("nested").unwrap(),
            &SchemaField::Nested(collection! {
                "test" => SchemaField::DataType(DataType::Uint64)
            })
        );
    }
}