//! payload related bits and bobs
use thiserror::Error;

use crate::block::content::Type as BlockEnum;
use crate::block::distribution::BridgeBlock;
use crate::block::simple::*;
use crate::block::{self, *};
use crate::content::{self, Content};
use crate::data::dynamic::DynType;
use crate::data::ReadError;
use crate::unit;

use super::BlockRegistry;

make_simple!(SimplePayloadBlock, |_, n, _, _, r: Rotation, scl| {
    match n {
        "deconstructor" | "small-deconstructor" | "payload-void" => {
            let mut base = load!(from n which is ["deconstructor" | "small-deconstructor" | "payload-void"], scl);
            let mut r#in = load!(scl -> match n {
                "small-deconstructor" => "factory-in-3",
                _ => "factory-in-5",
            });
            unsafe {
                base.overlay(r#in.rotate(r.rotated(false).count()))
                    .overlay(&load!(scl -> match n {
                        "small-deconstructor" => "small-deconstructor-top",
                        "deconstructor" => "deconstructor-top",
                        _ => "payload-void-top",
                    }))
            };
            base
        }
        // "payload-loader" | "payload-unloader"
        _ => {
            let mut base = load!(from n which is ["payload-loader" | "payload-unloader"], scl);
            let mut input = load!("factory-in-3-dark", scl);
            let mut output = load!("factory-out-3-dark", scl);
            unsafe {
                base.overlay(input.rotate(r.rotated(false).count()))
                .overlay(output.rotate(r.rotated(false).count()))
                .overlay(
                    &load!(concat "top" => n which is ["payload-loader" | "payload-unloader"], scl),
                )
            };
            base
        }
    }
});
make_simple!(
    PayloadConveyor,
    |_, n, _, _, r: Rotation, s| {
        let mut base =
            load!(from n which is ["payload-conveyor" | "reinforced-payload-conveyor"], s);
        unsafe { base.rotate(r.rotated(false).count()) };
        base
    },
    read_payload_conveyor
);
// make_simple!(PayloadRouter => read_payload_router);

make_register! {
    "payload-conveyor" => PayloadConveyor::new(3, false, cost!(Copper: 10, Graphite: 10));
    "payload-router" => PayloadBlock::new(3, false, cost!(Copper: 10, Graphite: 15));
    "reinforced-payload-conveyor" => PayloadConveyor::new(3, false, cost!(Tungsten: 10));
    "reinforced-payload-router" => PayloadBlock::new(3, false, cost!(Tungsten: 15));
    "payload-mass-driver" -> BridgeBlock::new(3, true, cost!(Tungsten: 120, Silicon: 120, Graphite: 50), 700, false);
    "large-payload-mass-driver" -> BridgeBlock::new(5, true, cost!(Thorium: 200, Tungsten: 200, Silicon: 200, Graphite: 100, Oxide: 30), 1100, false);
    "small-deconstructor" => SimplePayloadBlock::new(3, true, cost!(Beryllium: 100, Silicon: 100, Oxide: 40, Graphite: 80));
    "deconstructor" => SimplePayloadBlock::new(5, true, cost!(Beryllium: 250, Oxide: 100, Silicon: 250, Carbide: 250));
    "constructor" => PayloadBlock::new(3, true, cost!(Silicon: 100, Beryllium: 150, Tungsten: 80));
    "large-constructor" => PayloadBlock::new(5, true, cost!(Silicon: 150, Oxide: 150, Tungsten: 200, PhaseFabric: 40));
    "payload-loader" => SimplePayloadBlock::new(3, false, cost!(Graphite: 50, Silicon: 50, Tungsten: 80));
    "payload-unloader" => SimplePayloadBlock::new(3, false, cost!(Graphite: 50, Silicon: 50, Tungsten: 30));
    // sandbox only
    "payload-source" => PayloadBlock::new(5, false, &[]);
    "payload-void" => SimplePayloadBlock::new(5, true, &[]);
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
/// payload item cfg
pub enum Payload {
    Empty,
    Block(block::content::Type),
    Unit(unit::Type),
}

/// a payload related block with [item cfg](Payload)
pub struct PayloadBlock {
    size: u8,
    symmetric: bool,
    build_cost: BuildCost,
}

impl PayloadBlock {
    #[must_use]
    pub const fn new(size: u8, symmetric: bool, build_cost: BuildCost) -> Self {
        assert!(size != 0, "invalid size");
        Self {
            size,
            symmetric,
            build_cost,
        }
    }

    state_impl!(pub Payload);
}

impl BlockLogic for PayloadBlock {
    impl_block!();

    fn draw(
        &self,
        name: &str,
        _: Option<&State>,
        _: Option<&RenderingContext>,
        r: Rotation,
        s: Scale,
    ) -> ImageHolder<4> {
        match name {
            "payload-router" | "reinforced-payload-router" => {
                let mut base =
                    load!(from name which is ["payload-router" | "reinforced-payload-router"], s);
                unsafe {
                    base.rotate(r.rotated(false).count());
                    base.overlay(& load!(concat "over" => name which is ["payload-router" | "reinforced-payload-router"], s));
                }
                base
            }
            _ => {
                let mut base = load!(from name which is ["constructor" | "large-constructor" | "payload-source"], s);
                let mut out = load!(s -> match name {
                    "constructor" => "factory-out-3",
                    "large-constructor" => "factory-out-5-dark",
                    _ => "factory-out-5",
                });
                unsafe {
                    out.rotate(r.rotated(false).count());
                    base.overlay(&out);
                    base.overlay(&load!(concat "top" => name which is ["constructor" | "large-constructor" | "payload-source"], s))
                };
                base
            }
        }
    }

    fn data_from_i32(&self, _: i32, _: GridPos) -> Result<DynData, DataConvertError> {
        Ok(DynData::Empty)
    }

    fn deserialize_state(&self, data: DynData) -> Result<Option<State>, DeserializeError> {
        match data {
            DynData::Empty => Ok(Some(Self::create_state(Payload::Empty))),
            DynData::Content(content::Type::Block, id) => {
                let block = PayloadDeserializeError::forward(block::content::Type::try_from(id))?;
                Ok(Some(Self::create_state(Payload::Block(block))))
            }
            DynData::Content(content::Type::Unit, id) => {
                let unit = PayloadDeserializeError::forward(unit::Type::try_from(id))?;
                Ok(Some(Self::create_state(Payload::Unit(unit))))
            }
            DynData::Content(have, ..) => Err(DeserializeError::Custom(Box::new(
                PayloadDeserializeError::ContentType(have),
            ))),
            _ => Err(DeserializeError::InvalidType {
                have: data.get_type(),
                expect: DynType::Content,
            }),
        }
    }

    fn serialize_state(&self, state: &State) -> Result<DynData, SerializeError> {
        match Self::get_state(state) {
            Payload::Empty => Ok(DynData::Empty),
            Payload::Block(block) => Ok(DynData::Content(content::Type::Block, (*block).into())),
            Payload::Unit(unit) => Ok(DynData::Content(content::Type::Unit, (*unit).into())),
        }
    }
}

/// format:
/// - call [`read_payload_conveyor`]
/// - t: [`u8`]
/// - sort: [`u16`]
/// - recdir: [`u8`]
fn read_payload_router(
    b: &mut Build,
    reg: &BlockRegistry,
    entity_mapping: &EntityMapping,
    buff: &mut DataRead,
) -> Result<(), DataReadError> {
    read_payload_conveyor(b, reg, entity_mapping, buff)?;
    buff.skip(4)
}

/// format:
/// - [skip(4)](`DataRead::skip`)
/// - rot: [`f32`]
/// - become [`read_payload`]
fn read_payload_conveyor(
    _: &mut Build,
    reg: &BlockRegistry,
    entity_mapping: &EntityMapping,
    buff: &mut DataRead,
) -> Result<(), DataReadError> {
    buff.skip(8)?;
    read_payload(reg, entity_mapping, buff)
}

/// format:
/// - iterate [`i16`]..0
///     - [`u8`], [`i16`], [`i32`]
pub(crate) fn read_payload_seq(buff: &mut DataRead) -> Result<(), DataReadError> {
    let amount = (-buff.read_i16()?) as usize;
    buff.skip(amount * 7)
}

/// format:
/// - vector: ([`f32`], [`f32`])
/// - rotation: [`f32`]
/// - become [`read_payload`]
pub(crate) fn read_payload_block(
    reg: &BlockRegistry,
    entity_mapping: &EntityMapping,
    buff: &mut DataRead,
) -> Result<(), DataReadError> {
    buff.skip(12)?;
    read_payload(reg, entity_mapping, buff)
}

/// format:
/// - exists: [`bool`]
/// - if !exists: ok
/// - type: [`u8`]
/// - if type == `1` (payload block):
///     - block: [`u16`]
///     - version: [`u8`]
///     - [`BlockLogic::read`] (recursion :ferrisHmm:),
/// - if type == 2 (paylood unit):
///     - id: [`u8`]
///     - unit read???????? TODO
fn read_payload(
    reg: &BlockRegistry,
    entity_mapping: &crate::data::map::EntityMapping,
    buff: &mut DataRead,
) -> Result<(), DataReadError> {
    if !buff.read_bool()? {
        return Ok(());
    }
    let t = buff.read_u8()?;
    const BLOCK: u8 = 1;
    const UNIT: u8 = 0;
    match t {
        BLOCK => {
            let b = buff.read_u16()?;
            let b = BlockEnum::try_from(b).unwrap_or(BlockEnum::Router);
            let block = reg.get(b.get_name()).unwrap();
            block
                .logic
                .read(&mut Build::new(block), reg, entity_mapping, buff)?;
        }
        UNIT => {
            let u = buff.read_u8()?;
            let Some(_u) = entity_mapping.get(&u) else {
                return Err(ReadError::Expected("map entry"));
            };
            // unit::Type::try_from(u).unwrap_or(unit::Type::Alpha).read(todo!());
        }
        _ => return Err(ReadError::Expected("0 | 1")),
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;

    use crate::registry::Registry;

    use super::*;
    #[test]
    fn payload_conv() {
        let mut reg = Registry::default();
        register(&mut reg);
        let mut r = DataRead::new(&[0, 0, 0, 0, 0, 0, 0, 0, 0]);
        read_payload_conveyor(
            &mut Build::new(&PAYLOAD_CONVEYOR),
            &reg,
            &HashMap::default(),
            &mut r,
        )
        .unwrap();
        assert!(r.read_bool().is_err());
        let mut r = DataRead::new(&[
            65, 198, 232, 0, 67, 51, 255, 249, 1, 1, 0, 157, 0, 67, 197, 128, 0, 128, 1, 3,
        ]);
        read_payload_conveyor(
            &mut Build::new(&PAYLOAD_CONVEYOR),
            &reg,
            &HashMap::default(),
            &mut r,
        )
        .unwrap();
        assert!(r.read_bool().is_err());
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Error)]
pub enum PayloadDeserializeError {
    #[error("expected Unit or Block but got {0:?}")]
    ContentType(content::Type),
    #[error("payload block not found")]
    BlockNotFound(#[from] block::content::TryFromU16Error),
    #[error("payload unit not found")]
    UnitNotFound(#[from] unit::TryFromU16Error),
}

impl PayloadDeserializeError {
    pub fn forward<T, E: Into<Self>>(result: Result<T, E>) -> Result<T, DeserializeError> {
        match result {
            Ok(v) => Ok(v),
            Err(e) => Err(DeserializeError::Custom(Box::new(e.into()))),
        }
    }
}