use ch32_hal::timer::simple_pwm::SimplePwm;
use ch32_hal::timer::Channel;
use ch32_hal::timer::GeneralInstance16bit;

use crate::insert_coin::services::{DacService, LedService, Service, TickService, TickServiceData};

// static mut led0_index: usize = 0;
// static LED0: [u8; 8] = [0u8, 25u8, 50u8, 75u8, 100u8, 75u8, 50u8, 25u8];

// static mut LED1_INDEX: usize = 0;
// static LED1_DCS: [u8; 5] = [0u8, 25u8, 50u8, 75u8, 100u8];

pub struct SimplePwmCore<'d, T: GeneralInstance16bit> {
    pwm: core::cell::RefCell<SimplePwm<'d, T>>,
}

impl<'d, T: GeneralInstance16bit> SimplePwmCore<'d, T> {
    pub fn new(pwm: SimplePwm<'d, T>) -> Self {
        Self {
            pwm: core::cell::RefCell::new(pwm),
        }
    }

    // pub fn get_handle(&'d self, ch: Channel) -> SimplePwmHandle<'d, '_, T> {
    //     SimplePwmHandle {
    //         core: &self,
    //         channel: ch,
    //     }
    // }

    pub fn write_amplitude(&self, ch: Channel, amplitude: u8) {
        if !self.pwm.borrow().is_enabled(ch) {
            self.pwm.borrow_mut().enable(ch);
        }
        let max_duty = self.pwm.borrow().get_max_duty();
        let dc = amplitude as u32 * max_duty / 100;
        self.pwm.borrow_mut().set_duty(ch, dc);
    }

    // pub fn disable(&self, ch: Channel) {
    //     self.pwm.borrow_mut().disable(ch);
    // }
}

pub struct CoreConfig {
    pub tick_rate_hz: usize,
}
impl CoreConfig {
    pub fn new(tick_rate_hz: usize) -> Self {
        Self { tick_rate_hz }
    }
}

#[derive(Default)]
struct Core {
    _tick: usize,
    active: bool,
}

pub struct InsertCoin<'a, T: GeneralInstance16bit> {
    core: Core,
    pub config: CoreConfig,
    pwm_core: SimplePwmCore<'a, T>,
    pub led0: LedService,
    pub led1: LedService,
    // led2: LedService,
    pub dac: DacService<'a>,
}

impl<'a, T: GeneralInstance16bit> InsertCoin<'a, T> {
    pub fn new(config: CoreConfig, pwm_core: SimplePwmCore<'a, T>) -> Self {
        // LED0 servicer setup
        let led0 = LedService::new(ch32_hal::timer::Channel::Ch3);

        // LED1 servicer setup
        let led1 = LedService::new(ch32_hal::timer::Channel::Ch1);

        // DAC servicer setup
        let dac_sample_rate_hz = 4000;
        let dac_tick_per_service = config.tick_rate_hz / (dac_sample_rate_hz);
        let dac_service_data = TickServiceData::new(dac_tick_per_service);
        let dac = DacService::new(ch32_hal::timer::Channel::Ch4, dac_service_data);

        Self {
            config,
            core: Default::default(),
            pwm_core,
            led0,
            led1,
            // led2,
            dac,
        }
    }

    /// takes self reference and runs
    pub fn service(&mut self) {
        if self.is_active() {
            self.dac.tick();

            if self.led0.need_service() {
                self.pwm_core
                    .write_amplitude(self.led0.channel, self.led0.amplitude);
                self.led0.service();
            }

            if self.led1.need_service() {
                self.pwm_core
                    .write_amplitude(self.led1.channel, self.led1.amplitude);
                self.led1.service();
            }

            if self.dac.need_service() {
                self.dac.service();
                // TODO: adpcm-pwm-dac:e4c811653781e69e40b63fd27a8c1e20
                self.pwm_core
                    .write_amplitude(self.dac.channel, self.dac.get_amplitude() as u8);
            }
        }
    }

    // /// consumes self and runs
    // pub fn run(mut self) -> ! {
    //     let mut delay = Delay;
    //     let tick_interval_us = 1000000/self.config.tick_rate_hz;

    //     let mut led0_index = 0;
    //     let led0_dcs = [0u8, 25u8, 50u8, 75u8, 100u8, 75u8, 50u8, 25u8];

    //     let mut led1_index = 0;
    //     let led1_dcs = [0u8, 25u8, 50u8, 75u8, 100u8];

    //     loop {
    //         self.dac.tick();

    //         if(self.led0.need_service()) {
    //             self.led0.set_amplitude(led0_dcs[led0_index]);
    //             self.pwm_core.write_amplitude(self.led0.channel, self.led0.amplitude);

    //             led0_index += 1;
    //             if led0_index > led0_dcs.len() - 1 {
    //                 led0_index = 0;
    //             }
    //             self.led0.service();
    //         }

    //         if(self.led1.need_service()) {
    //             self.led1.set_amplitude(led1_dcs[led1_index]);
    //             self.pwm_core.write_amplitude(self.led1.channel, self.led1.amplitude);

    //             led1_index += 1;
    //             if led1_index > led1_dcs.len() - 1 {
    //                 led1_index = 0;
    //             }
    //             self.led1.service();
    //         }

    //         if(self.dac.need_service()) {
    //             self.dac.service();
    //             // TODO: adpcm-pwm-dac:e4c811653781e69e40b63fd27a8c1e20
    //             self.pwm_core.write_amplitude(self.dac.channel, self.dac.get_amplitude() as u8);
    //         }

    //         delay.delay_us(tick_interval_us as u32);
    //     }
    // }

    pub fn is_active(&self) -> bool {
        self.core.active
    }

    pub fn set_active(&mut self, active: bool) {
        self.core.active = active;
    }
}