use std::io::{BufRead, Cursor};
use std::str;
use std::sync::Arc;

use async_trait::async_trait;
use bitflags::bitflags;
use byteorder::{BigEndian, ReadBytesExt};
use bytes::{Buf, BytesMut};
use chrono::{DateTime, Duration, NaiveDateTime, Utc};
use figment::value::Map;
use futures::future::join;
use influxdb2::models::DataPoint;
use influxdb2::models::data_point::DataPointBuilder;
use itertools::Itertools;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, ReadHalf, WriteHalf};
use tokio::sync::Mutex;
use tokio::time::sleep;
use tokio::{join, select};
use tokio_serial::{SerialPort, SerialStream};
use tokio_util::sync::CancellationToken;
use tracing::{debug, info, warn};

use crate::{
    ChimemonMessage, ChimemonSource, ChimemonSourceChannel, SourceMetric, SourceReportDetails,
    TimeReport, UCCMConfig,
};

pub const GPS_EPOCH: i64 = 315964800; // Doesn't seem possible to have a const DateTime object
pub type UccmEndian = BigEndian;

pub enum UCCMMonitorParseState {
    Idle,
    ReadStatus,
    ReadLoopDiag,
    ReadTOD,
}

pub struct UCCMMonitor {
    pub name: String,
    config: UCCMConfig,
    rx: ReadHalf<SerialStream>,
    tx: WriteHalf<SerialStream>,
    pub info: Option<UCCMInfo>,
}

#[derive(Debug)]
pub struct UCCMTODReport {
    pub time: DateTime<Utc>, // TAI timestamp
    pub leaps: i8,
    pub flags: UCCMFlags,
}

impl SourceReportDetails for UCCMTODReport {
    fn is_healthy(&self) -> bool {
        self.flags.contains(UCCMFlags::OSC_LOCK)
            && self.flags.contains(UCCMFlags::HAVE_GPS_TIME)
            && !self.flags.contains(UCCMFlags::INIT_UNLOCK)
            && !self.flags.contains(UCCMFlags::INIT_NO_SATS)
            && !self.flags.contains(UCCMFlags::POWER_FAIL)
            && !self.flags.contains(UCCMFlags::NO_GPS_SYNC)
            && !self.flags.contains(UCCMFlags::NO_GPS_SYNC2)
            && !self.flags.contains(UCCMFlags::NO_ANT)
            && !self.flags.contains(UCCMFlags::GPS_LOS)
    }

    fn to_metrics(&self) -> Vec<SourceMetric> {
        let no_tags = Arc::new(vec![]);
        vec![
            SourceMetric::new_int("leaps", self.leaps as i64, no_tags.clone()),
            SourceMetric::new_bool(
                "osc_lock",
                self.flags.contains(UCCMFlags::OSC_LOCK),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "leap_flag",
                self.flags.contains(UCCMFlags::LEAP_FLAG),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "init_unlock",
                self.flags.contains(UCCMFlags::INIT_UNLOCK),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "init_no_sats",
                self.flags.contains(UCCMFlags::INIT_NO_SATS),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "have_gps_time",
                self.flags.contains(UCCMFlags::HAVE_GPS_TIME),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "power_fail",
                self.flags.contains(UCCMFlags::POWER_FAIL),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "no_gps_sync",
                self.flags.contains(UCCMFlags::NO_GPS_SYNC),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "no_gps_sync2",
                self.flags.contains(UCCMFlags::NO_GPS_SYNC2),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "ant_fault",
                self.flags.contains(UCCMFlags::NO_ANT),
                no_tags.clone(),
            ),
            SourceMetric::new_bool(
                "gps_los",
                self.flags.contains(UCCMFlags::GPS_LOS),
                no_tags.clone(),
            ),
        ]
    }
}

impl UCCMTODReport {
    pub fn as_builder(&self, measurement: &String, tags: &Map<String, String>) -> DataPointBuilder {
        let mut builder =
            DataPoint::builder(measurement).timestamp(self.time.timestamp_nanos_opt().unwrap());
        builder = builder.field("leaps", self.leaps as i64);
        builder = builder.field("osc_lock", self.flags.contains(UCCMFlags::OSC_LOCK));
        builder = builder.field("leap_flag", self.flags.contains(UCCMFlags::LEAP_FLAG));
        builder = builder.field("init_unlock", self.flags.contains(UCCMFlags::INIT_UNLOCK));
        builder = builder.field("init_no_sats", self.flags.contains(UCCMFlags::INIT_NO_SATS));
        builder = builder.field(
            "have_gps_time",
            self.flags.contains(UCCMFlags::HAVE_GPS_TIME),
        );
        builder = builder.field("power_fail", self.flags.contains(UCCMFlags::POWER_FAIL));
        builder = builder.field("no_gps_sync", self.flags.contains(UCCMFlags::NO_GPS_SYNC));
        builder = builder.field("no_gps_sync2", self.flags.contains(UCCMFlags::NO_GPS_SYNC2));
        builder = builder.field("ant_fault", self.flags.contains(UCCMFlags::NO_ANT));
        builder = builder.field("gps_los", self.flags.contains(UCCMFlags::GPS_LOS));

        builder = tags
            .iter()
            .fold(builder, |builder, (k, v)| builder.tag(k, v));

        builder
    }
}

#[derive(Debug)]
pub struct UCCMLoopDiagReport {
    pub ocxo: f32,
}

impl UCCMLoopDiagReport {
    pub fn as_builder(&self, measurement: &String, tags: &Map<String, String>) -> DataPointBuilder {
        let mut builder = DataPoint::builder(measurement);
        builder = builder.field("ocxo_offset", self.ocxo as f64);
        builder = tags
            .iter()
            .fold(builder, |builder, (k, v)| builder.tag(k, v));
        builder
    }
}

#[derive(Debug)]
pub struct UCCMGpsSvTracking {
    pub sv: u8,
    pub cno: u8,
}

impl UCCMGpsSvTracking {
    fn as_builder(&self, measurement: &String, tags: &Map<String, String>) -> DataPointBuilder {
        let mut builder = DataPoint::builder(measurement)
            .field("sv_cno", self.cno as i64)
            .tag("sv_id", self.sv.to_string());
        builder = tags
            .iter()
            .fold(builder, |builder, (k, v)| builder.tag(k, v));

        builder
    }
}

#[derive(Debug)]
pub struct UCCMGPSSatsReport {
    pub tracked_svs: Vec<UCCMGpsSvTracking>,
}

impl UCCMGPSSatsReport {
    pub fn build(&self, measurement: &String, tags: &Map<String, String>) -> Vec<DataPoint> {
        self.tracked_svs
            .iter()
            .map(|sv| sv.as_builder(measurement, tags))
            .map(|b| b.build().unwrap())
            .collect()
    }
}

bitflags! {
    #[derive(Debug)]
    pub struct UCCMFlags: u32 {
        const OSC_LOCK = (1<<29);
        const LEAP_FLAG = (1<<25);
        const INIT_UNLOCK = (1<<24);

        const INIT_NO_SATS = (1<<19);
        const HAVE_GPS_TIME = (1<<18);
        const POWER_FAIL = (1<<17);

        const MODEL_SYMMETRICOM = (1<<15);
        const MODEL_TRIMBLE = (1<<14);
        const NO_GPS_SYNC = (1<<11);
        const NO_GPS_SYNC2 = (1<<9);

        const MODEL_SYMMETRICOM2 = (1<<7);
        const MODEL_TRIMBLE2 = (1<<6);
        const NO_ANT = (1<<5);
        const GPS_LOS = (1<<4);
    }
}

/* FLAGS:
    MSB 31 x
        30 ALWAYS 1
        29 oscillator locked
        28..26 x
        25 leap flag
        24 initial unlock

        23..20 x
        19 initialized no sats (trimble)
        18 have gps time flag
        17 power fail
        16 x

        15..14 model/protocol ( 01 = trimble 10 = symmetricom )
        13..12 x
        11 no gps sync
        10 always 1
        9 no gps sync
        8 always 1

        7..6 model/protocol ( 01 = trimble 10 = symmetricom )
        5 no ant
        4 gps los
    LSB 3..0 x
*/

#[derive(Debug)]
pub struct GPSSVInfo {
    pub tracked: bool,
    pub in_view: bool,
    pub prn: u8,
    pub elevation: usize,
    pub azimuth: usize,
    pub cn0: usize,
}

#[derive(Debug)]
pub struct UCCMStatusReport {
    pub tfom: u8,
    pub ffom: u8,
    pub gps_phase: f32,
    pub gps_pps_valid: bool,
    pub gps_svs: [GPSSVInfo; 32],
    pub gps_time: NaiveDateTime,
    pub ant_voltage: f32,
    pub ant_current: f32,
    pub temp: f32,
    pub efc_dac: u32,
    pub freq_error: f32,
}

impl SourceReportDetails for UCCMStatusReport {
    fn is_healthy(&self) -> bool {
        self.gps_pps_valid
    }
    fn to_metrics(&self) -> Vec<SourceMetric> {
        let no_tags = Arc::new(vec![]);
        vec![
            SourceMetric::new_int("tfom", self.tfom as i64, no_tags.clone()),
            SourceMetric::new_int("ffom", self.ffom as i64, no_tags.clone()),
            SourceMetric::new_float("gps_phase", self.gps_phase as f64, no_tags.clone()),
            // TODO: sv info
            // TOOD: timestamp
            SourceMetric::new_float("ant_voltage", self.ant_voltage as f64, no_tags.clone()),
            SourceMetric::new_float("ant_current", self.ant_current as f64, no_tags.clone()),
            SourceMetric::new_float("temp", self.temp as f64, no_tags.clone()),
            SourceMetric::new_int("efc_dac", self.efc_dac as i64, no_tags.clone()),
            SourceMetric::new_float("freq_error", self.freq_error as f64, no_tags.clone()),
        ]
    }
}

pub struct UCCMInfo {
    pub vendor: String,
    pub model: String,
    pub serial: String,
    pub version: String,
}

impl TryFrom<&[u8]> for UCCMTODReport {
    type Error = String;
    fn try_from(strbuf: &[u8]) -> Result<Self, Self::Error> {
        debug!("TOD buffer: `{:#?}`", String::from_utf8(strbuf.to_vec()));
        let resp: Vec<u8> = strbuf
            .split(|c| *c == b' ')
            .map(|x| u8::from_str_radix(str::from_utf8(x).unwrap_or(""), 16).unwrap_or(0))
            .collect();
        let mut rdr = Cursor::new(resp);

        // Sync flag
        let c = rdr.read_u16::<UccmEndian>().unwrap();
        if c != 0xc500 {
            return Err(format!("Missing start delimter (got: `{}`)", c));
        }

        // Consume 25 unknown bytes
        rdr.advance(25);
        let time = rdr.read_u32::<UccmEndian>().unwrap();
        rdr.advance(1); // consume padding
        let leaps = rdr.read_i8().unwrap();
        let flags = rdr.read_u32::<UccmEndian>().unwrap();
        debug!("Flags: {}", flags);
        rdr.advance(6); // Consume padding and checksum, don't check it
        let c = rdr.read_u8().unwrap();
        if c != 0xca {
            return Err(format!("Missing end delimiter (got: `{}`)", c));
        }
        debug!("TOD time: {} leaps: {} flags: {}", time, leaps, flags);

        Ok(UCCMTODReport {
            time: DateTime::from_timestamp(GPS_EPOCH + time as i64, 0).unwrap(),
            leaps,
            flags: UCCMFlags::from_bits_truncate(flags),
        })
    }
}

impl TryFrom<&str> for UCCMLoopDiagReport {
    type Error = std::io::Error;
    fn try_from(strbuf: &str) -> Result<Self, Self::Error> {
        debug!("LoopDiag buffer: `{:#?}`", strbuf);

        if &strbuf[0..4] != "OCXO" {
            Err(std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                "Invalid response (expected `OCXO`)",
            ))
        } else {
            let mut cursor = Cursor::new(strbuf);
            let mut lines = BufRead::lines(&mut cursor);
            let ocxo_line = lines.next().ok_or(std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                "No lines!",
            ))??;
            let ocxo_val = ocxo_line
                .split(':')
                .nth(1)
                .ok_or(std::io::Error::new(
                    std::io::ErrorKind::InvalidData,
                    "no colon!",
                ))?
                .trim();
            let ocxo_val_f = ocxo_val
                .parse::<f32>()
                .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
            Ok(UCCMLoopDiagReport { ocxo: ocxo_val_f })
        }
    }
}

impl TryFrom<&str> for UCCMGPSSatsReport {
    type Error = std::io::Error;
    fn try_from(strbuf: &str) -> Result<Self, Self::Error> {
        let resp = strbuf.split_once('\n').unwrap().0.trim();
        let (nsats, cnos) = resp.split_once(' ').ok_or(std::io::Error::new(
            std::io::ErrorKind::InvalidData,
            "Invalid response (expected `NSATS CNOS`)",
        ))?;
        let nsats = nsats.parse::<u8>().map_err(|e| {
            std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                format!("Invalid number of sats ({e})"),
            )
        })?;
        let tracked_svs = cnos
            .split(',')
            .chunks(2)
            .into_iter()
            .map(|chunk| chunk.collect_tuple().unwrap())
            .inspect(|chunk| debug!(" chunk: {:?}", chunk))
            .map(|(sv_s, cno_s)| UCCMGpsSvTracking {
                sv: sv_s.parse().unwrap(),
                cno: cno_s.parse().unwrap(),
            })
            .collect_vec();
        assert_eq!(nsats as usize, tracked_svs.len());
        Ok(UCCMGPSSatsReport { tracked_svs })
    }
}

impl UCCMMonitor {
    pub async fn send_cmd(&mut self, cmd: &[u8]) -> Result<String, std::io::Error> {
        debug!("cmd: `{:?}`", String::from_utf8_lossy(cmd));
        self.tx.write_all(cmd).await.unwrap();
        self.tx.write_u8(b'\n').await.unwrap();
        let mut reader = BufReader::new(&mut self.rx);
        let mut resp = String::new();
        while !resp.contains("UCCM>") {
            debug!("'{}' doesn't contain UCCM>", resp);
            let mut buf = Vec::new();
            reader.read_until(b'>', &mut buf).await.unwrap();
            resp.push_str(&String::from_utf8_lossy(&buf));
        }

        // Remove the command we sent from the response
        resp.replace_range(0..resp.find('\n').unwrap_or(0) + 1, "");
        resp = resp.replace("\r", "");
        debug!("cmd response: `{:?}`", resp);
        Ok(resp)
    }

    pub async fn get_info(&mut self) -> Result<(), std::io::Error> {
        self.send_cmd(b"SCPI").await.unwrap_or_default();
        self.send_cmd(b"TOD DI").await.unwrap_or_default();
        sleep(tokio::time::Duration::from_secs(1)).await;
        let resp = self.send_cmd(b"*IDN?").await.unwrap_or_default();
        let info: Vec<&str> = resp.lines().next().unwrap().split(',').collect();
        debug!("Response length: {}", info.len());
        if info.len() != 4 {
            return Err(std::io::Error::new(
                std::io::ErrorKind::Unsupported,
                "Unexpected *IDN? response",
            ));
        }
        self.info = Some(UCCMInfo {
            vendor: info[0].into(),
            model: info[1].into(),
            serial: info[2].into(),
            version: info[3].into(),
        });
        info!(
            "Found {} {} s/n: {} version: {}",
            self.info.as_ref().unwrap().vendor,
            self.info.as_ref().unwrap().model,
            self.info.as_ref().unwrap().serial,
            self.info.as_ref().unwrap().version
        );
        Ok(())
    }

    async fn rx_loop(
        mut self,
        chan: ChimemonSourceChannel,
        state: Arc<Mutex<UCCMMonitorParseState>>,
    ) {
        let mut rdbuf = BytesMut::with_capacity(1024);
        let mut last_loop_diag: Option<UCCMLoopDiagReport> = None;
        let mut last_gps_sats: Option<UCCMGPSSatsReport> = None;

        let mut last_sent_report = Utc::now() - self.config.status_interval;

        loop {
            match tokio::io::AsyncReadExt::read_buf(&mut self.rx, &mut rdbuf).await {
                Ok(n) => {
                    if n == 0 {
                        continue;
                    }
                }
                Err(_) => continue,
            }
            match *state.lock().await {
                UCCMMonitorParseState::Idle => {
                    while !rdbuf.starts_with(b"c5 00") && rdbuf.remaining() > 0 {
                        rdbuf.advance(1);
                    }
                    if rdbuf.len() < (44 * 2 + 43) {
                        // TOD frame is 44 bytes, plus 43 spaces
                        continue;
                    };
                    let frame = rdbuf.split_to(44 * 2 + 43);
                    match UCCMTODReport::try_from(&frame[..]) {
                        Ok(tod) => {
                            let sysnow = Utc::now();
                            let offset = tod.time - Duration::seconds(tod.leaps as i64) - sysnow;
                            debug!(
                                "System time: {:#?} GPS time: {:#?} Leaps: {:#?}",
                                sysnow, tod.time, tod.leaps
                            );
                            debug!("TOD offset: {}ms", offset.num_milliseconds());
                            info!("{:#?}", tod);
                            let valid = tod.leaps > 0
                                && tod
                                    .flags
                                    .contains(UCCMFlags::OSC_LOCK | UCCMFlags::HAVE_GPS_TIME);
                            chan.send(ChimemonMessage::TimeReport(TimeReport {
                                system_time: sysnow,
                                offset,
                                leaps: tod.leaps as isize,
                                leap_flag: tod.flags.contains(UCCMFlags::LEAP_FLAG),
                                valid,
                            }))
                            .expect("Unable to send to channel");
                            if sysnow - last_sent_report
                                >= Duration::from_std(self.config.status_interval).unwrap()
                            {
                                // let mut points = vec![
                                //     tod.as_builder(&self.config.measurement, &self.config.tags)
                                //         .build()
                                //         .unwrap(),
                                // ];
                                // if let Some(loop_diag) = &last_loop_diag {
                                //     points.push(
                                //         loop_diag
                                //             .as_builder(
                                //                 &self.config.measurement,
                                //                 &self.config.influxdb.tags,
                                //             )
                                //             .build()
                                //             .unwrap(),
                                //     )
                                // }
                                // if let Some(gps_sats) = &last_gps_sats {
                                //     points.extend(gps_sats.build(
                                //         &self.config.sources.uccm.measurement,
                                //         &self.config.influxdb.tags,
                                //     ));
                                // }

                                // chan.send(ChimemonMessage::DataPoints(points))
                                //     .expect("Unable to send to channel");
                                last_sent_report = sysnow;
                            }
                        }
                        Err(e) => {
                            warn!("Unable to parse TOD frame: {}", e);
                            rdbuf.clear();
                        }
                    }
                    let loop_diag_resp = self.send_cmd(b"DIAG:LOOP?").await.unwrap();
                    let gps_sats_resp = self.send_cmd(b"GPSSAT").await.unwrap();
                    let loop_report = UCCMLoopDiagReport::try_from(loop_diag_resp.as_str());
                    let gps_report = UCCMGPSSatsReport::try_from(gps_sats_resp.as_str());
                    if let Ok(loop_report) = loop_report {
                        last_loop_diag = Some(loop_report)
                    } else {
                        warn!(
                            "Unable to parse loop diag report `{}`: {}",
                            loop_diag_resp,
                            loop_report.unwrap_err()
                        );
                    }
                    if let Ok(gps_report) = gps_report {
                        last_gps_sats = Some(gps_report)
                    } else {
                        warn!(
                            "Unable to parse GPS sats report `{}`: {}",
                            gps_sats_resp,
                            gps_report.unwrap_err()
                        );
                    }
                }
                UCCMMonitorParseState::ReadLoopDiag => todo!(),
                UCCMMonitorParseState::ReadStatus => todo!(),
                UCCMMonitorParseState::ReadTOD => todo!(),
            }
        }
    }
}

#[async_trait]
impl ChimemonSource for UCCMMonitor {
    type Config = UCCMConfig;
    fn new(name: &str, config: Self::Config) -> Self {
        let builder = tokio_serial::new(&config.port, config.baud)
            .timeout(config.timeout)
            .data_bits(tokio_serial::DataBits::Eight)
            .parity(tokio_serial::Parity::None)
            .stop_bits(tokio_serial::StopBits::One)
            .flow_control(tokio_serial::FlowControl::None);
        let mut port = SerialStream::open(&builder).expect("Must be able to open serial port");
        port.set_exclusive(true).expect("Can't lock serial port");
        info!(
            "Opened serial port {}@{}",
            port.name().unwrap(),
            port.baud_rate().unwrap()
        );
        let (rx, tx) = tokio::io::split(port);
        UCCMMonitor {
            name: name.to_owned(),
            config,
            rx,
            tx,
            info: None,
        }
    }

    async fn run(mut self, chan: ChimemonSourceChannel, cancel: CancellationToken) {
        info!("UCCM task starting");
        if self.get_info().await.is_err() {
            warn!("Error starting UCCM");
            return;
        }
        self.send_cmd(b"SCPI").await.unwrap();
        self.send_cmd(b"SYSTem:PRESet").await.unwrap();
        self.send_cmd(b"OUTPut:TP:SELection PP1S").await.unwrap();
        self.send_cmd(b"TESTMODE EN").await.unwrap();
        self.send_cmd(b"TOD EN").await.unwrap();
        let state = Arc::new(Mutex::<UCCMMonitorParseState>::new(
            UCCMMonitorParseState::Idle,
        ));

        let rx_handle = tokio::spawn(self.rx_loop(chan.clone(), state.clone()));

        // let tx_handle = tokio::spawn(async move {
        //     let mut interval = interval(self.config.status_interval);
        //     loop {
        //         interval.tick().await;
        //         let wfut = self.tx.write_all(b"SYST:STAT?\n");
        //         *state.lock().await = UCCMMonitorParseState::ReadStatus;
        //         wfut.await;
        //     }
        // });
        //
        select! {
            _ = cancel.cancelled() => { return },
            _ = rx_handle => { return }
        };

        join!(rx_handle).0.unwrap();
    }
}