use crate::error::{Error, Result};
use crate::model::{Amount, AssetId, ByteString};
use crate::util::JsonDeserializer;
use crate::waves_proto::{Amount as ProtoAmount, ReissueTransactionData};
use serde_json::{Map, Value};

const TYPE: u8 = 5;

#[derive(Clone, Eq, PartialEq, Debug)]
pub struct ReissueTransactionInfo {
    amount: Amount,
    reissuable: bool,
}

impl ReissueTransactionInfo {
    pub fn new(amount: Amount, reissuable: bool) -> Self {
        Self { amount, reissuable }
    }

    pub fn amount(&self) -> Amount {
        self.amount.clone()
    }

    pub fn is_reissuable(&self) -> bool {
        self.reissuable
    }
}

impl TryFrom<&Value> for ReissueTransactionInfo {
    type Error = Error;

    fn try_from(value: &Value) -> Result<Self> {
        let quantity = JsonDeserializer::safe_to_int_from_field(value, "quantity")?;
        let asset_id = match value["assetId"].as_str() {
            Some(asset) => Some(AssetId::from_string(asset)?),
            None => None,
        };
        let reissuable = JsonDeserializer::safe_to_boolean_from_field(value, "reissuable")?;

        Ok(ReissueTransactionInfo {
            amount: Amount::new(quantity as u64, asset_id),
            reissuable,
        })
    }
}

#[derive(Clone, Eq, PartialEq, Debug)]
pub struct ReissueTransaction {
    amount: Amount,
    reissuable: bool,
}

impl ReissueTransaction {
    pub fn new(amount: Amount, reissuable: bool) -> Self {
        Self { amount, reissuable }
    }

    pub fn tx_type() -> u8 {
        TYPE
    }

    pub fn amount(&self) -> Amount {
        self.amount.clone()
    }

    pub fn is_reissuable(&self) -> bool {
        self.reissuable
    }
}

impl TryFrom<&Value> for ReissueTransaction {
    type Error = Error;

    fn try_from(value: &Value) -> Result<Self> {
        let quantity = JsonDeserializer::safe_to_int_from_field(value, "quantity")?;
        let asset_id = match value["assetId"].as_str() {
            Some(asset) => Some(AssetId::from_string(asset)?),
            None => None,
        };
        let reissuable = JsonDeserializer::safe_to_boolean_from_field(value, "reissuable")?;

        Ok(ReissueTransaction {
            amount: Amount::new(quantity as u64, asset_id),
            reissuable,
        })
    }
}

impl TryFrom<&ReissueTransaction> for Map<String, Value> {
    type Error = Error;

    fn try_from(value: &ReissueTransaction) -> Result<Self> {
        let mut issue_tx_json = Map::new();
        issue_tx_json.insert(
            "assetId".to_owned(),
            value
                .amount
                .asset_id()
                .map(|asset| asset.encoded().into())
                .unwrap_or(Value::Null),
        );
        issue_tx_json.insert("quantity".to_owned(), value.amount.value().into());
        issue_tx_json.insert("reissuable".to_owned(), value.reissuable.into());
        Ok(issue_tx_json)
    }
}

impl TryFrom<&ReissueTransaction> for ReissueTransactionData {
    type Error = Error;

    fn try_from(value: &ReissueTransaction) -> Result<Self> {
        let asset_id = match value.amount.asset_id() {
            Some(asset) => asset.bytes(),
            None => vec![],
        };
        let amount = Some(ProtoAmount {
            asset_id,
            amount: value.amount.value() as i64,
        });

        Ok(ReissueTransactionData {
            asset_amount: amount,
            reissuable: value.reissuable,
        })
    }
}

#[cfg(test)]
mod tests {
    use crate::error::Result;
    use crate::model::{Amount, AssetId, ByteString, ReissueTransaction, ReissueTransactionInfo};
    use crate::waves_proto::ReissueTransactionData;
    use serde_json::{json, Map, Value};
    use std::borrow::Borrow;
    use std::fs;

    #[test]
    fn test_json_to_reissue_transaction() {
        let data =
            fs::read_to_string("./tests/resources/reissue_rs.json").expect("Unable to read file");
        let json: Value = serde_json::from_str(&data).expect("failed to generate json from str");

        let reissue_from_json: ReissueTransactionInfo = json.borrow().try_into().unwrap();

        assert_eq!(
            "8bt2MZjuUCJPmfucPfaZPTXqrxmoCHCC8gVnbjZ7bhH6",
            reissue_from_json
                .amount()
                .asset_id()
                .expect("failed")
                .encoded()
        );
        assert_eq!(12, reissue_from_json.amount().value());
        assert_eq!(true, reissue_from_json.is_reissuable());
    }

    #[test]
    fn test_reissue_to_proto() -> Result<()> {
        let reissue_tx = &ReissueTransaction::new(
            Amount::new(
                32,
                Some(AssetId::from_string(
                    "8bt2MZjuUCJPmfucPfaZPTXqrxmoCHCC8gVnbjZ7bhH6",
                )?),
            ),
            true,
        );
        let proto: ReissueTransactionData = reissue_tx.try_into()?;

        assert_eq!(proto.reissuable, reissue_tx.is_reissuable());
        let amount = proto.asset_amount.unwrap();
        assert_eq!(amount.amount as u64, reissue_tx.amount().value());
        assert_eq!(
            amount.asset_id,
            reissue_tx.amount().asset_id().unwrap().bytes()
        );
        Ok(())
    }

    #[test]
    fn test_reissue_to_json() -> Result<()> {
        let reissue_tx = &ReissueTransaction::new(
            Amount::new(
                32,
                Some(AssetId::from_string(
                    "8bt2MZjuUCJPmfucPfaZPTXqrxmoCHCC8gVnbjZ7bhH6",
                )?),
            ),
            true,
        );

        let map: Map<String, Value> = reissue_tx.try_into()?;
        let json: Value = map.into();
        let expected_json = json!({
            "assetId": "8bt2MZjuUCJPmfucPfaZPTXqrxmoCHCC8gVnbjZ7bhH6",
            "quantity": 32,
            "reissuable": true
        });
        assert_eq!(expected_json, json);
        Ok(())
    }
}