//
// Copyright (C) 2018 Kubos Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License")
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

use failure::Error;
use kubos_service::{process_errors, push_err, run};
use log::{error, info};
use novatel_oem6_api::Log::*;
use novatel_oem6_api::*;
use std::sync::mpsc::{sync_channel, Receiver, SyncSender, TryRecvError, TrySendError};
use std::sync::{Arc, Mutex, RwLock};
use std::thread;
use std::time::Duration;

use crate::objects::*;

pub const RECV_TIMEOUT: Duration = Duration::from_millis(350);

pub struct LockData {
    pub status: Mutex<LockStatus>,
    pub info: Mutex<LockInfo>,
}

impl LockData {
    pub fn new() -> Self {
        LockData {
            status: Mutex::new(LockStatus::default()),
            info: Mutex::new(LockInfo::default()),
        }
    }

    pub fn update_status(&self, status: LockStatus) {
        let mut local = self.status.lock().unwrap();
        *local = status;
    }

    pub fn update_info(&self, info: LockInfo) {
        let mut local = self.info.lock().unwrap();
        *local = info;
    }
}

// Listen for log messages from the OEM6 and route data to the appropriate
// listener or structure.
//
// The OEM6 will send us one of three log messages:
// - Lock information. The OEM6 will likely be set up to output this data
//   once per second.
// - Version information. This data will be output immediately upon request by
//   the `noop` and `get_test_results` functions
// - Error information. If enabled, this will be output by the OEM6 when an
//   error or event occurs.
pub fn log_thread(
    oem: &OEM6,
    data: &Arc<LockData>,
    error_send: &SyncSender<RxStatusEventLog>,
    version_send: &SyncSender<VersionLog>,
) {
    loop {
        match oem.get_log().unwrap_or_else(|err| {
            error!("get_log failed: {:?}. Log read thread bailing", err);
            panic!("Underlying read thread no longer communicating")
        }) {
            BestXYZ(log) => {
                if log.pos_status == 0 && log.vel_status == 0 {
                    data.update_info(LockInfo {
                        time: OEMTime {
                            week: i32::from(log.week),
                            ms: log.ms,
                        },
                        position: log.position,
                        velocity: log.velocity,
                    });
                }
                data.update_status(LockStatus {
                    time_status: log.time_status,
                    time: OEMTime {
                        week: i32::from(log.week),
                        ms: log.ms,
                    },
                    position_status: log.pos_status,
                    position_type: log.pos_type,
                    velocity_status: log.vel_status,
                    velocity_type: log.vel_type,
                });
            }
            RxStatusEvent(log) => error_send
                .try_send(log)
                .or_else::<TrySendError<RxStatusEventLog>, _>(|err| match err {
                    // Our buffer is full, but the receiver should still be alive, so let's keep going
                    TrySendError::Full(_) => Ok(()),
                    TrySendError::Disconnected(_) => {
                        let msg =
                            "Error receiver disconnected. Assuming system has become corrupted";
                        error!("{}", msg);
                        panic!("{}", msg);
                    }
                })
                .unwrap(),
            Version(log) => version_send
                .try_send(log)
                .or_else::<TrySendError<VersionLog>, _>(|err| match err {
                    // Our buffer is full, but the receiver should still be alive, so let's keep going
                    TrySendError::Full(_) => Ok(()),
                    TrySendError::Disconnected(_) => {
                        let msg =
                            "Version receiver disconnected. Assuming system has become corrupted";
                        error!("{}", msg);
                        panic!("{}", msg)
                    }
                })
                .unwrap(),
        }
    }
}

#[derive(Clone)]
pub struct Subsystem {
    pub oem: OEM6,
    pub last_cmd: Arc<RwLock<AckCommand>>,
    pub errors: Arc<RwLock<Vec<String>>>,
    pub lock_data: Arc<LockData>,
    pub error_recv: Arc<Mutex<Receiver<RxStatusEventLog>>>,
    pub version_recv: Arc<Mutex<Receiver<VersionLog>>>,
}

impl Subsystem {
    pub fn new(bus: &str, data: Arc<LockData>) -> OEMResult<Subsystem> {
        let (log_send, log_recv) = sync_channel(5);
        let (response_send, response_recv) = sync_channel(5);
        let (response_abbrv_send, response_abbrv_recv) = sync_channel(5);

        let oem = OEM6::new(
            bus,
            BaudRate::Baud9600,
            log_recv,
            response_recv,
            response_abbrv_recv,
        )?;

        let rx_conn = oem.conn.clone();
        thread::spawn(move || {
            read_thread(&rx_conn, &log_send, &response_send, &response_abbrv_send)
        });

        let (error_send, error_recv) = sync_channel(10);
        let (version_send, version_recv) = sync_channel(1);

        let data_ref = data.clone();
        let oem_ref = oem.clone();
        thread::spawn(move || log_thread(&oem_ref, &data_ref, &error_send, &version_send));

        info!("Kubos OEM6 service started");

        Ok(Subsystem {
            oem,
            last_cmd: Arc::new(RwLock::new(AckCommand::None)),
            errors: Arc::new(RwLock::new(vec![])),
            lock_data: data,
            error_recv: Arc::new(Mutex::new(error_recv)),
            version_recv: Arc::new(Mutex::new(version_recv)),
        })
    }

    fn get_version_log(&self) -> Result<VersionLog, String> {
        let result = match self.oem.request_version() {
            Ok(_) => match self
                .version_recv
                .lock()
                .map_err(|err| format!("Failed to obtain version_recv mutex: {:?}", err))?
                .recv_timeout(RECV_TIMEOUT)
            {
                Ok(log) => Ok(log),
                Err(err) => Err(format!("Failed to receive version info - {}", err)),
            },
            Err(err) => Err(process_errors!(err)),
        };

        if result.is_err() {
            error!("{:?}", result);
        }

        result
    }

    // Queries

    pub fn get_errors(&self) {
        if let Ok(recv) = self.error_recv.lock() {
            match recv.try_recv() {
                Ok(msg) => {
                    push_err!(
                        self.errors,
                        format!(
                            "RxStatusEvent({}, {}, {}): {}",
                            msg.word, msg.bit, msg.event, msg.description
                        )
                    );

                    while let Ok(err) = recv.try_recv() {
                        push_err!(
                            self.errors,
                            format!(
                                "RxStatusEvent({}, {}, {}): {}",
                                err.word, err.bit, err.event, err.description
                            )
                        );
                    }
                }
                Err(err) => match err {
                    // Do nothing. This is the good case
                    TryRecvError::Empty => {}
                    // We've lost connection with the errors channel
                    TryRecvError::Disconnected => {
                        push_err!(self.errors, "Errors sender disconnected".to_owned());
                    }
                },
            }
        } else {
            push_err!(self.errors, "Failed to obtain error_recv mutex".to_owned());
        }
    }

    pub fn get_power(&self) -> Result<GetPowerResponse, Error> {
        let (state, uptime) = if self.get_version_log().is_ok() {
            (PowerState::On, 1)
        } else {
            (PowerState::Off, 0)
        };

        Ok(GetPowerResponse { state, uptime })
    }

    pub fn get_system_status(&self) -> Result<SystemStatus, Error> {
        self.get_errors();

        let mut errors = match self.errors.read() {
            Ok(master_vec) => master_vec.clone(),
            _ => {
                error!("get_system_status - Failed to borrow master errors vector");
                vec!["Error: Failed to borrow master errors vector".to_owned()]
            }
        };

        let status = match self.get_version_log() {
            Ok(log) => log.recv_status,
            Err(err) => {
                errors.push(format!("System Status: {}", err));
                /* My first thought was to use ReceiverStatusFlags::empty(),
                 * but I'm worried that that is easily mistaken for this function
                 * actually having succeeded
                 */
                ReceiverStatusFlags::all()
            }
        };

        Ok(SystemStatus {
            status: ReceiverStatus(status),
            errors,
        })
    }

    pub fn get_lock_status(&self) -> Result<LockStatus, Error> {
        Ok(self.lock_data.status.lock().unwrap().clone())
    }

    pub fn get_lock_info(&self) -> Result<LockInfo, Error> {
        Ok(self.lock_data.info.lock().unwrap().clone())
    }

    pub fn get_test_results(&self) -> Result<IntegrationTestResults, Error> {
        let telem = self.get_telemetry()?;

        Ok(IntegrationTestResults {
            success: telem.debug.is_some(),
            errors: telem.nominal.system_status.errors.join("; "),
            telemetry_debug: telem.debug.clone(),
            telemetry_nominal: telem.nominal,
        })
    }

    pub fn get_telemetry(&self) -> Result<Telemetry, Error> {
        self.get_errors();

        let mut errors = match self.errors.read() {
            Ok(master_vec) => master_vec.clone(),
            _ => {
                error!("get_telemetry - Failed to borrow master errors vector");
                vec!["Error: Failed to borrow master errors vector".to_owned()]
            }
        };

        let (status, version_info) = match self.get_version_log() {
            Ok(log) => (
                log.recv_status,
                Some(VersionInfo {
                    num_components: log.num_components as i32,
                    components: log
                        .components
                        .iter()
                        .map(|comp| VersionComponent(comp.clone()))
                        .collect(),
                }),
            ),
            Err(err) => {
                let temp = format!("Get Telemetry: {}", err);
                errors.push(temp.clone());
                push_err!(self.errors, temp);
                (ReceiverStatusFlags::all(), None)
            }
        };

        let lock_status = self.get_lock_status().ok();
        let lock_info = self.get_lock_info().ok();

        Ok(Telemetry {
            nominal: TelemetryNominal {
                system_status: SystemStatus {
                    status: ReceiverStatus(status),
                    errors,
                },
                lock_status,
                lock_info,
            },
            debug: version_info,
        })
    }

    // Mutations

    pub fn noop(&self) -> Result<GenericResponse, Error> {
        let result = self.get_version_log();

        let success = result.is_ok();

        let errors = match result {
            Ok(_) => "".to_owned(),
            Err(err) => {
                let temp = format!("Noop: {}", err);
                push_err!(self.errors, temp);
                err
            }
        };

        Ok(GenericResponse { success, errors })
    }

    pub fn configure_hardware(
        &self,
        input: Vec<ConfigStruct>,
    ) -> Result<ConfigureHardwareResponse, Error> {
        let mut success = true;
        let mut errors = "".to_owned();
        let mut config = "".to_owned();

        for entry in input.iter() {
            let result = run!(
                match entry.option {
                    ConfigOption::LogErrorData => self.oem.request_errors(entry.hold),
                    ConfigOption::LogPositionData => {
                        self.oem
                            .request_position(entry.interval, entry.offset, entry.hold)
                    }
                    ConfigOption::UnlogAll => self.oem.request_unlog_all(entry.hold),
                    ConfigOption::UnlogErrorData => {
                        self.oem.request_unlog(MessageID::RxStatusEvent)
                    }
                    ConfigOption::UnlogPositionData => self.oem.request_unlog(MessageID::BestXYZ),
                },
                self.errors
            );

            success &= result.is_ok();
            if let Err(err) = result {
                if !errors.is_empty() {
                    errors.push_str(". ");
                }
                errors.push_str(&format!("{:?}: {}", entry.option, err));
            }

            if !config.is_empty() {
                config.push_str(", ");
            }
            config.push_str(&format!("{:?}(Hold: {})", entry.option, entry.hold));
            if entry.interval != 0.0 {
                config.push_str(&format!(": {}+{}sec", entry.interval, entry.offset));
            }
        }

        Ok(ConfigureHardwareResponse {
            success,
            errors,
            config,
        })
    }

    pub fn passthrough(&self, command: String) -> Result<GenericResponse, Error> {
        // Convert the hex values in the string into actual hex values
        // Ex. "c3c2" -> [0xc3, 0xc2]
        let tx: Vec<u8> = command
            .as_bytes()
            .chunks(2)
            .map(|chunk| u8::from_str_radix(::std::str::from_utf8(chunk).unwrap(), 16).unwrap())
            .collect();

        let result = run!(self.oem.passthrough(tx.as_slice()), self.errors);

        Ok(GenericResponse {
            success: result.is_ok(),
            errors: match result {
                Ok(_) => "".to_owned(),
                Err(err) => err,
            },
        })
    }
}