use std::time::Instant;
use control_core::socketio::namespace::NamespaceCacheingLogic;
use ethercat_hal::io::{
    digital_input::DigitalInput,
    digital_output::DigitalOutput,
};
use smol::channel::{Receiver, Sender};

use self::api::{StateEvent, WagoDioSeparateEvents, WagoDioSeparateNamespace};
use crate::{
    AsyncThreadMessage, Machine, MachineMessage,
    VENDOR_QITECH, MACHINE_WAGO_DIO_SEPARATE_V1,
    machine_identification::{MachineIdentification, MachineIdentificationUnique},
};

pub mod act;
pub mod api;
pub mod new;

#[derive(Debug)]
pub struct WagoDioSeparate {
    pub api_receiver: Receiver<MachineMessage>,
    pub api_sender: Sender<MachineMessage>,
    pub machine_identification_unique: MachineIdentificationUnique,
    pub main_sender: Option<Sender<AsyncThreadMessage>>,
    pub namespace: WagoDioSeparateNamespace,
    pub last_state_emit: Instant,

    // I/O state
    pub inputs: [bool; 8],        // current DI readings (750-430)
    pub led_on: [bool; 8],        // current DO states    (750-530)

    // Hardware handles
    pub digital_input: [DigitalInput; 8],   // bound to 750-430 ports
    pub digital_output: [DigitalOutput; 8], // bound to 750-530 ports
}

impl WagoDioSeparate {
    /// Read all 8 digital inputs and emit the full state to the frontend.
    pub fn emit_state(&mut self) {
        for (i, di) in self.digital_input.iter().enumerate() {
            self.inputs[i] = match di.get_value() {
                Ok(v) => v,
                Err(_) => false,
            };
        }
        let event = self.get_state().build();
        self.namespace.emit(WagoDioSeparateEvents::State(event));
    }

    /// Set a single digital output by index.
    pub fn set_led(&mut self, index: usize, on: bool) {
        if index < self.led_on.len() {
            self.led_on[index] = on;
            self.digital_output[index].set(on);
            self.emit_state();
        }
    }

    /// Set all 8 digital outputs at once.
    pub fn set_all_leds(&mut self, on: bool) {
        self.led_on = [on; 8];
        for dout in self.digital_output.iter() {
            dout.set(on);
        }
        self.emit_state();
    }
}

impl MachineNewTrait for WagoDioSeparate {
    fn new<'maindevice>(params: &MachineNewParams) -> Result<Self, Error> {
        // Validate device group
        let device_identification = params.device_group.iter()
            .map(|d| d.clone()).collect::<Vec<_>>();
        validate_same_machine_identification_unique(&device_identification)?;
        validate_no_role_duplicates(&device_identification)?;

        let hardware = match &params.hardware {
            MachineNewHardware::Ethercat(x) => x,
            _ => return Err(anyhow::anyhow!(
                "MachineNewHardware is not Ethercat"
            )),
        };

        block_on(async {
            // 1. Get the 750-354 coupler
            let wago_750_354 = get_ethercat_device::<Wago750_354>(
                hardware, params, 0,
                [WAGO_750_354_IDENTITY_A].to_vec(),
            ).await?;

            // 2. Initialize all attached modules
            let modules = Wago750_354::initialize_modules(
                wago_750_354.1
            ).await?;
            let mut coupler = wago_750_354.0.write().await;
            for module in modules {
                coupler.set_module(module);
            }
            coupler.init_slot_modules(wago_750_354.1);

            // 3. Get the 750-430 (slot 0 = first module)
            let dev_input = coupler.slot_devices.get(0)
                .ok_or_else(|| anyhow::anyhow!(
                    "Expected 750-430 in slot 0"
                ))?.clone()
                .ok_or_else(|| anyhow::anyhow!(
                    "Slot 0 is empty"
                ))?;
            let wago750_430: Arc<RwLock<Wago750_430>> =
                downcast_device::<Wago750_430>(dev_input).await?;

            // 4. Get the 750-530 (slot 1 = second module)
            let dev_output = coupler.slot_devices.get(1)
                .ok_or_else(|| anyhow::anyhow!(
                    "Expected 750-530 in slot 1"
                ))?.clone()
                .ok_or_else(|| anyhow::anyhow!(
                    "Slot 1 is empty"
                ))?;
            let wago750_530: Arc<RwLock<Wago750_530>> =
                downcast_device::<Wago750_530>(dev_output).await?;

            // 5. Create digital I/O handles for all 8 ports
            let di1 = DigitalInput::new(wago750_430.clone(), Wago750_430Port::Port1);
            let di2 = DigitalInput::new(wago750_430.clone(), Wago750_430Port::Port2);
            // ... (di3 through di8)
            let di8 = DigitalInput::new(wago750_430.clone(), Wago750_430Port::Port8);

            let do1 = DigitalOutput::new(wago750_530.clone(), Wago750_530Port::Port1);
            let do2 = DigitalOutput::new(wago750_530.clone(), Wago750_530Port::Port2);
            // ... (do3 through do8)
            let do8 = DigitalOutput::new(wago750_530.clone(), Wago750_530Port::Port8);

            drop(coupler);

            // 6. Construct the machine
            let (sender, receiver) = smol::channel::unbounded();
            let mut machine = Self {
                api_receiver: receiver,
                api_sender: sender,
                machine_identification_unique: params
                    .get_machine_identification_unique(),
                namespace: WagoDioSeparateNamespace {
                    namespace: params.namespace.clone(),
                },
                last_state_emit: Instant::now(),
                inputs: [false; 8],
                led_on: [false; 8],
                main_sender: params.main_thread_channel.clone(),
                digital_input:  [di1, di2, di3, di4, di5, di6, di7, di8],
                digital_output: [do1, do2, do3, do4, do5, do6, do7, do8],
            };
            machine.emit_state();
            Ok(machine)
        })
    }
}

impl MachineAct for WagoDioSeparate {
    fn act(&mut self, now: Instant) {
        // Process any queued API messages (mutations from the frontend)
        if let Ok(msg) = self.api_receiver.try_recv() {
            self.act_machine_message(msg);
        }

        // Emit state at ~30 Hz
        if now.duration_since(self.last_state_emit)
            > Duration::from_secs_f64(1.0 / 30.0)
        {
            self.emit_state();
            self.last_state_emit = now;
        }
    }

    fn act_machine_message(&mut self, msg: MachineMessage) {
        match msg {
            MachineMessage::SubscribeNamespace(namespace) => {
                self.namespace.namespace = Some(namespace);
                self.emit_state();
            }
            MachineMessage::UnsubscribeNamespace => {
                self.namespace.namespace = None;
            }
            MachineMessage::HttpApiJsonRequest(value) => {
                use crate::MachineApi;
                let _res = self.api_mutate(value);
            }
            MachineMessage::RequestValues(sender) => {
                sender.send_blocking(MachineValues {
                    state: serde_json::to_value(self.get_state())
                        .expect("Failed to serialize state"),
                    live_values: serde_json::Value::Null,
                }).expect("Failed to send values");
                sender.close();
            }
        }
    }
}

// === State Event (sent to frontend at ~30 Hz) ===
#[derive(Serialize, Debug, Clone)]
pub struct StateEvent {
    pub inputs: [bool; 8],  // 750-430 readings
    pub led_on: [bool; 8],  // 750-530 states
}

// === Mutations (received from frontend) ===
#[derive(Deserialize)]
#[serde(tag = "action", content = "value")]
pub enum Mutation {
    SetLed { index: usize, on: bool },
    SetAllLeds { on: bool },
}

// === API implementation ===
impl MachineApi for WagoDioSeparate {
    fn api_mutate(
        &mut self,
        request_body: Value,
    ) -> Result<(), anyhow::Error> {
        let mutation: Mutation = serde_json::from_value(request_body)?;
        match mutation {
            Mutation::SetLed { index, on } => self.set_led(index, on),
            Mutation::SetAllLeds { on } => self.set_all_leds(on),
        }
        Ok(())
    }
}