use crate::requests::{Request, RequestWithToken};
use crate::tmtc::TmStore;
use eurosim_obsw::tmtc_err;
use satrs_core::mode::ModeAndSubmode;
use satrs_core::pool::StoreAddr;
use satrs_core::pus::mode::Subservice::TmModeReply;
use satrs_core::pus::verification::{
    FailParams, TcStateStarted, VerificationReporterWithSender, VerificationToken,
};
use satrs_core::pus::MpscPusInStoreSendError;
use satrs_core::seq_count::{SeqCountProviderSyncClonable, SequenceCountProviderCore};
use satrs_core::spacepackets::time::cds::TimeProvider;
use satrs_core::spacepackets::time::TimeWriter;
use satrs_core::spacepackets::tm::{PusTm, PusTmSecondaryHeader};
use satrs_core::spacepackets::SpHeader;
use std::sync::mpsc::Sender;
use log::info;

#[derive(Clone)]
pub struct VerifHelper {
    verif_reporter: VerificationReporterWithSender<MpscPusInStoreSendError>,
    time_stamp_buf: [u8; 7],
}

impl VerifHelper {
    pub fn new(verif_reporter: VerificationReporterWithSender<MpscPusInStoreSendError>) -> Self {
        Self {
            verif_reporter,
            time_stamp_buf: [0; 7],
        }
    }

    pub fn start_and_unwrap(
        &mut self,
        request_with_token: RequestWithToken,
    ) -> Result<(Request, Option<VerificationToken<TcStateStarted>>), ()> {
        match request_with_token.1 {
            None => Ok((request_with_token.0, None)),
            Some(token) => {
                self.update_time_stamp();
                if let Ok(start_token) = self //implement this for verification
                    .verif_reporter
                    .start_success(token, Some(&self.time_stamp_buf))
                {
                    return Ok((request_with_token.0, Some(start_token)));
                } else {
                    return Err(());
                }
            }
        }
    }

    pub fn start_failure(&mut self, request_with_token: RequestWithToken) -> Result<(), ()> {
        if let Some(token) = request_with_token.1 {
            self.update_time_stamp();
            if let Ok(()) = self.verif_reporter.start_failure(
                token,
                FailParams::new(
                    Some(&mut self.time_stamp_buf),
                    &tmtc_err::INVALID_PUS_SUBSERVICE,
                    None,
                ),
            ) {
                return Ok(());
            } else {
                return Err(());
            }
        }
        Ok(())
    }

    pub fn completion(&mut self, start_token: VerificationToken<TcStateStarted>) -> Result<(), ()> {
        self.update_time_stamp();
        if let Ok(()) = self
            .verif_reporter
            .completion_success(start_token, Some(&self.time_stamp_buf))
        {
            return Ok(());
        } else {
            return Err(());
        }
    }

    pub fn completion_failure(
        &mut self,
        start_token: VerificationToken<TcStateStarted>,
    ) -> Result<(), ()> {
        self.update_time_stamp();
        if let Ok(()) = self.verif_reporter.completion_failure(
            start_token,
            FailParams::new(
                Some(&mut self.time_stamp_buf),
                &tmtc_err::INVALID_PUS_SUBSERVICE,
                None,
            ),
        ) {
            return Ok(());
        } else {
            return Err(());
        }
    }

    fn update_time_stamp(&mut self) {
        let cds_stamp = TimeProvider::from_now_with_u16_days().unwrap();
        cds_stamp.write_to_bytes(&mut self.time_stamp_buf).unwrap();
    }
}

pub struct ModeHelper {
    apid: u16,
    seq_count_provider: SeqCountProviderSyncClonable,
    tm_store: TmStore,
    tm_funnel_tx: Sender<StoreAddr>,
    buf: [u8; 6],
    time_stamp_buf: [u8; 7],
}

impl ModeHelper {
    pub fn new(
        apid: u16,
        seq_count_provider: SeqCountProviderSyncClonable,
        tm_store: TmStore,
        tm_funnel_tx: Sender<StoreAddr>,
    ) -> Self {
        Self {
            apid,
            seq_count_provider,
            tm_store,
            tm_funnel_tx,
            buf: [0; 6],
            time_stamp_buf: [0; 7],
        }
    }

    fn update_time_stamp(&mut self) {
        let cds_stamp = TimeProvider::from_now_with_u16_days().unwrap();
        cds_stamp.write_to_bytes(&mut self.time_stamp_buf).unwrap();
    }

    pub fn make_and_send_mode_reply(
        &mut self,
        mode_submode: ModeAndSubmode,
    ) -> Result<(), std::sync::mpsc::SendError<StoreAddr>> {
        info!("mode reply generated from apid {}", self.apid);
        self.update_time_stamp();
        let mut sp_header =
            SpHeader::tm_unseg(self.apid, self.seq_count_provider.get_and_increment(), 0).unwrap();
        self.buf[0..4].copy_from_slice(&mode_submode.mode().to_be_bytes());
        self.buf[4..6].copy_from_slice(&mode_submode.submode().to_be_bytes());
        let len = 6;
        let data = self.buf[0..len].to_vec();
        let tm_sec_header =
            PusTmSecondaryHeader::new_simple(200, TmModeReply as u8, &self.time_stamp_buf);
        let tm = PusTm::new(&mut sp_header, tm_sec_header, Some(&self.buf[0..len]), true);
        let addr = self.tm_store.add_pus_tm(&tm);
        self.tm_funnel_tx.send(addr)
    }
}