use crate::config::PlantControllerConfig;
use crate::hal::battery::BatteryInteraction;
use crate::hal::esp::Esp;
use crate::hal::rtc::RTCModuleInteraction;
use crate::hal::water::TankSensor;
use crate::hal::{
    deep_sleep, BoardInteraction, FreePeripherals, Sensor, I2C_DRIVER, PLANT_COUNT,
    REPEAT_MOIST_MEASURE,
};
use crate::log::{log, LogMessage};
use anyhow::bail;
use embedded_hal::digital::OutputPin;
use embedded_hal_bus::i2c::MutexDevice;
use esp_idf_hal::delay::Delay;
use esp_idf_hal::gpio::{AnyInputPin, IOPin, InputOutput, Output, PinDriver, Pull};
use esp_idf_hal::i2c::I2cDriver;
use esp_idf_hal::pcnt::{
    PcntChannel, PcntChannelConfig, PcntControlMode, PcntCountMode, PcntDriver, PinIndex,
};
use esp_idf_sys::{gpio_hold_dis, gpio_hold_en};
use ina219::address::{Address, Pin};
use ina219::calibration::UnCalibrated;
use ina219::configuration::{Configuration, OperatingMode};
use ina219::SyncIna219;
use measurements::{Current, Resistance, Voltage};
use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};
use std::result::Result::Ok as OkStd;

const MS0: u8 = 1_u8;
const MS1: u8 = 0_u8;
const MS2: u8 = 3_u8;
const MS3: u8 = 4_u8;
const MS4: u8 = 2_u8;
const SENSOR_ON: u8 = 5_u8;

pub enum Charger<'a> {
    SolarMpptV1 {
        mppt_ina: SyncIna219<MutexDevice<'a, I2cDriver<'a>>, UnCalibrated>,
        solar_is_day: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
        charge_indicator: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
    },
    ErrorInit {},
}

impl Charger<'_> {
    pub(crate) fn power_save(&mut self) {
        match self {
            Charger::SolarMpptV1 { mppt_ina, .. } => {
                let _ = mppt_ina
                    .set_configuration(Configuration {
                        reset: Default::default(),
                        bus_voltage_range: Default::default(),
                        shunt_voltage_range: Default::default(),
                        bus_resolution: Default::default(),
                        shunt_resolution: Default::default(),
                        operating_mode: OperatingMode::PowerDown,
                    })
                    .map_err(|e| {
                        println!(
                    "Error setting ina mppt configuration during deep sleep preparation{:?}",
                    e
                );
                    });
            }
            _ => {}
        }
    }
    fn set_charge_indicator(&mut self, charging: bool) -> anyhow::Result<()> {
        match self {
            Self::SolarMpptV1 {
                charge_indicator, ..
            } => {
                charge_indicator.set_state(charging.into())?;
            }
            _ => {}
        }
        Ok(())
    }

    fn is_day(&self) -> bool {
        match self {
            Charger::SolarMpptV1 { solar_is_day, .. } => solar_is_day.get_level().into(),
            _ => true,
        }
    }

    fn get_mptt_voltage(&mut self) -> anyhow::Result<Voltage> {
        let voltage = match self {
            Charger::SolarMpptV1 { mppt_ina, .. } => mppt_ina
                .bus_voltage()
                .map(|v| Voltage::from_millivolts(v.voltage_mv() as f64))?,
            _ => {
                bail!("hardware error during init")
            }
        };
        Ok(voltage)
    }

    fn get_mptt_current(&mut self) -> anyhow::Result<Current> {
        let current = match self {
            Charger::SolarMpptV1 { mppt_ina, .. } => mppt_ina.shunt_voltage().map(|v| {
                let shunt_voltage = Voltage::from_microvolts(v.shunt_voltage_uv().abs() as f64);
                let shut_value = Resistance::from_ohms(0.05_f64);
                let current = shunt_voltage.as_volts() / shut_value.as_ohms();
                Current::from_amperes(current)
            })?,
            _ => {
                bail!("hardware error during init")
            }
        };
        Ok(current)
    }
}

pub struct V4<'a> {
    esp: Esp<'a>,
    tank_sensor: TankSensor<'a>,
    charger: Charger<'a>,
    rtc_module: Box<dyn RTCModuleInteraction + Send>,
    battery_monitor: Box<dyn BatteryInteraction + Send>,
    config: PlantControllerConfig,
    signal_counter: PcntDriver<'a>,
    awake: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, Output>,
    light: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
    general_fault: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
    pump_expander: Pca9535Immediate<MutexDevice<'a, I2cDriver<'a>>>,
    pump_ina: Option<SyncIna219<MutexDevice<'a, I2cDriver<'a>>, UnCalibrated>>,
    sensor_expander: Pca9535Immediate<MutexDevice<'a, I2cDriver<'a>>>,
    extra1: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, Output>,
    extra2: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, Output>,
}

pub(crate) fn create_v4(
    peripherals: FreePeripherals,
    esp: Esp<'static>,
    config: PlantControllerConfig,
    battery_monitor: Box<dyn BatteryInteraction + Send>,
    rtc_module: Box<dyn RTCModuleInteraction + Send>,
) -> anyhow::Result<Box<dyn BoardInteraction<'static> + Send + 'static>> {
    let mut awake = PinDriver::output(peripherals.gpio21.downgrade())?;
    awake.set_high()?;

    let mut general_fault = PinDriver::input_output(peripherals.gpio23.downgrade())?;
    general_fault.set_pull(Pull::Floating)?;
    general_fault.set_low()?;

    let mut extra1 = PinDriver::output(peripherals.gpio6.downgrade())?;
    extra1.set_low()?;

    let mut extra2 = PinDriver::output(peripherals.gpio15.downgrade())?;
    extra2.set_low()?;

    let one_wire_pin = peripherals.gpio18.downgrade();
    let tank_power_pin = peripherals.gpio11.downgrade();
    let flow_sensor_pin = peripherals.gpio4.downgrade();

    let tank_sensor = TankSensor::create(
        one_wire_pin,
        peripherals.adc1,
        peripherals.gpio5,
        tank_power_pin,
        flow_sensor_pin,
        peripherals.pcnt1
    )?;

    let mut signal_counter = PcntDriver::new(
        peripherals.pcnt0,
        Some(peripherals.gpio22),
        Option::<AnyInputPin>::None,
        Option::<AnyInputPin>::None,
        Option::<AnyInputPin>::None,
    )?;

    signal_counter.channel_config(
        PcntChannel::Channel0,
        PinIndex::Pin0,
        PinIndex::Pin1,
        &PcntChannelConfig {
            lctrl_mode: PcntControlMode::Keep,
            hctrl_mode: PcntControlMode::Keep,
            pos_mode: PcntCountMode::Increment,
            neg_mode: PcntCountMode::Hold,
            counter_h_lim: i16::MAX,
            counter_l_lim: 0,
        },
    )?;

    let mut solar_is_day = PinDriver::input(peripherals.gpio7.downgrade())?;
    solar_is_day.set_pull(Pull::Floating)?;

    let mut light = PinDriver::input_output(peripherals.gpio10.downgrade())?;
    light.set_pull(Pull::Floating)?;

    let mut charge_indicator = PinDriver::input_output(peripherals.gpio3.downgrade())?;
    charge_indicator.set_pull(Pull::Floating)?;
    charge_indicator.set_low()?;

    let mut pump_expander = Pca9535Immediate::new(MutexDevice::new(&I2C_DRIVER), 32);
    for pin in 0..8 {
        let _ = pump_expander.pin_into_output(GPIOBank::Bank0, pin);
        let _ = pump_expander.pin_into_output(GPIOBank::Bank1, pin);
        let _ = pump_expander.pin_set_low(GPIOBank::Bank0, pin);
        let _ = pump_expander.pin_set_low(GPIOBank::Bank1, pin);
    }

    let mut sensor_expander = Pca9535Immediate::new(MutexDevice::new(&I2C_DRIVER), 34);
    for pin in 0..8 {
        let _ = sensor_expander.pin_into_output(GPIOBank::Bank0, pin);
        let _ = sensor_expander.pin_into_output(GPIOBank::Bank1, pin);
        let _ = sensor_expander.pin_set_low(GPIOBank::Bank0, pin);
        let _ = sensor_expander.pin_set_low(GPIOBank::Bank1, pin);
    }

    let mppt_ina = SyncIna219::new(
        MutexDevice::new(&I2C_DRIVER),
        Address::from_pins(Pin::Vcc, Pin::Gnd),
    );

    let charger = match mppt_ina {
        Ok(mut mppt_ina) => {
            mppt_ina.set_configuration(Configuration {
                reset: Default::default(),
                bus_voltage_range: Default::default(),
                shunt_voltage_range: Default::default(),
                bus_resolution: Default::default(),
                shunt_resolution: ina219::configuration::Resolution::Avg128,
                operating_mode: Default::default(),
            })?;

            Charger::SolarMpptV1 {
                mppt_ina,
                solar_is_day,
                charge_indicator,
            }
        }
        Err(_) => Charger::ErrorInit {},
    };

    let pump_ina = match SyncIna219::new(
        MutexDevice::new(&I2C_DRIVER),
        Address::from_pins(Pin::Gnd, Pin::Sda),
    ) {
        Ok(pump_ina) => Some(pump_ina),
        Err(err) => {
            println!("Error creating pump ina: {:?}", err);
            None
        }
    };

    let v = V4 {
        rtc_module,
        esp,
        awake,
        tank_sensor,
        signal_counter,
        light,
        general_fault,
        pump_ina,
        pump_expander,
        sensor_expander,
        config,
        battery_monitor,
        charger,
        extra1,
        extra2,
    };
    Ok(Box::new(v))
}

impl<'a> BoardInteraction<'a> for V4<'a> {
    fn get_tank_sensor(&mut self) -> Option<&mut TankSensor<'a>> {
        Some(&mut self.tank_sensor)
    }

    fn get_esp(&mut self) -> &mut Esp<'a> {
        &mut self.esp
    }

    fn get_config(&mut self) -> &PlantControllerConfig {
        &self.config
    }

    fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send> {
        &mut self.battery_monitor
    }

    fn get_rtc_module(&mut self) -> &mut Box<dyn RTCModuleInteraction + Send> {
        &mut self.rtc_module
    }

    fn set_charge_indicator(&mut self, charging: bool) -> anyhow::Result<()> {
        self.charger.set_charge_indicator(charging)
    }

    fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
        self.awake.set_low().unwrap();
        self.charger.power_save();
        deep_sleep(duration_in_ms);
    }

    fn is_day(&self) -> bool {
        self.charger.is_day()
    }

    fn light(&mut self, enable: bool) -> anyhow::Result<()> {
        unsafe { gpio_hold_dis(self.light.pin()) };
        self.light.set_state(enable.into())?;
        unsafe { gpio_hold_en(self.light.pin()) };
        anyhow::Ok(())
    }

    fn pump(&mut self, plant: usize, enable: bool) -> anyhow::Result<()> {
        if enable {
            self.pump_expander
                .pin_set_high(GPIOBank::Bank0, plant.try_into()?)?;
        } else {
            self.pump_expander
                .pin_set_low(GPIOBank::Bank0, plant.try_into()?)?;
        }
        anyhow::Ok(())
    }

    fn pump_current(&mut self, _plant: usize) -> anyhow::Result<Current> {
        //sensore is shared for all pumps, ignore plant id
        match self.pump_ina.as_mut() {
            None => {
                bail!("pump current sensor not available");
            }
            Some(pump_ina) => {
                let v = pump_ina.shunt_voltage().map(|v| {
                    let shunt_voltage = Voltage::from_microvolts(v.shunt_voltage_uv().abs() as f64);
                    let shut_value = Resistance::from_ohms(0.05_f64);
                    let current = shunt_voltage.as_volts() / shut_value.as_ohms();
                    Current::from_amperes(current)
                })?;
                Ok(v)
            }
        }
    }

    fn fault(&mut self, plant: usize, enable: bool) -> anyhow::Result<()> {
        if enable {
            self.pump_expander
                .pin_set_high(GPIOBank::Bank1, plant.try_into()?)?
        } else {
            self.pump_expander
                .pin_set_low(GPIOBank::Bank1, plant.try_into()?)?
        }
        anyhow::Ok(())
    }

    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> anyhow::Result<f32> {
        let mut results = [0_f32; REPEAT_MOIST_MEASURE];
        for repeat in 0..REPEAT_MOIST_MEASURE {
            self.signal_counter.counter_pause()?;
            self.signal_counter.counter_clear()?;

            //Disable all
            self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS4)?;

            let sensor_channel = match sensor {
                Sensor::A => plant as u32,
                Sensor::B => (15 - plant) as u32,
            };

            let is_bit_set = |b: u8| -> bool { sensor_channel & (1 << b) != 0 };
            if is_bit_set(0) {
                self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS0)?;
            } else {
                self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS0)?;
            }
            if is_bit_set(1) {
                self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS1)?;
            } else {
                self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS1)?;
            }
            if is_bit_set(2) {
                self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS2)?;
            } else {
                self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS2)?;
            }
            if is_bit_set(3) {
                self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS3)?;
            } else {
                self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS3)?;
            }

            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS4)?;
            self.sensor_expander
                .pin_set_high(GPIOBank::Bank0, SENSOR_ON)?;

            let delay = Delay::new_default();
            let measurement = 100; // TODO what is this scaling factor? what is its purpose?
            let factor = 1000f32 / measurement as f32;

            //give some time to stabilize
            delay.delay_ms(10);
            self.signal_counter.counter_resume()?;
            delay.delay_ms(measurement);
            self.signal_counter.counter_pause()?;
            self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS4)?;
            self.sensor_expander
                .pin_set_low(GPIOBank::Bank0, SENSOR_ON)?;
            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS0)?;
            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS1)?;
            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS2)?;
            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS3)?;
            delay.delay_ms(10);
            let unscaled = self.signal_counter.get_counter_value()? as i32;
            let hz = unscaled as f32 * factor;
            log(
                LogMessage::RawMeasure,
                unscaled as u32,
                hz as u32,
                &plant.to_string(),
                &format!("{sensor:?}"),
            );
            results[repeat] = hz;
        }
        results.sort_by(|a, b| a.partial_cmp(b).unwrap()); // floats don't seem to implement total_ord

        let mid = results.len() / 2;
        let median = results[mid];
        anyhow::Ok(median)
    }

    fn general_fault(&mut self, enable: bool) {
        unsafe { gpio_hold_dis(self.general_fault.pin()) };
        self.general_fault.set_state(enable.into()).unwrap();
        unsafe { gpio_hold_en(self.general_fault.pin()) };
    }

    fn test(&mut self) -> anyhow::Result<()> {
        self.general_fault(true);
        self.esp.delay.delay_ms(100);
        self.general_fault(false);
        self.esp.delay.delay_ms(500);
        self.light(true)?;
        self.esp.delay.delay_ms(500);
        self.light(false)?;
        self.esp.delay.delay_ms(500);
        for i in 0..PLANT_COUNT {
            self.fault(i, true)?;
            self.esp.delay.delay_ms(500);
            self.fault(i, false)?;
            self.esp.delay.delay_ms(500);
        }
        for i in 0..PLANT_COUNT {
            self.pump(i, true)?;
            self.esp.delay.delay_ms(100);
            self.pump(i, false)?;
            self.esp.delay.delay_ms(100);
        }
        for plant in 0..PLANT_COUNT {
            let a = self.measure_moisture_hz(plant, Sensor::A);
            let b = self.measure_moisture_hz(plant, Sensor::B);
            let aa = match a {
                OkStd(a) => a as u32,
                Err(_) => u32::MAX,
            };
            let bb = match b {
                OkStd(b) => b as u32,
                Err(_) => u32::MAX,
            };
            log(LogMessage::TestSensor, aa, bb, &plant.to_string(), "");
        }
        self.esp.delay.delay_ms(10);
        anyhow::Ok(())
    }

    fn set_config(&mut self, config: PlantControllerConfig) -> anyhow::Result<()> {
        self.config = config;
        self.esp.save_config(&self.config)?;
        anyhow::Ok(())
    }

    fn get_mptt_voltage(&mut self) -> anyhow::Result<Voltage> {
        self.charger.get_mptt_voltage()
    }

    fn get_mptt_current(&mut self) -> anyhow::Result<Current> {
        self.charger.get_mptt_current()
    }
}