use anyhow::Result;
use clap::{crate_authors, crate_description, crate_name, crate_version, Clap};
use serial_embedded_hal::{PortSettings, Serial};
use spidriver::SPIDriver;

use std::io;

#[derive(Clap)]
#[clap(name = crate_name!(), version = crate_version!(),
       author = crate_authors!(","), about = crate_description!())]
struct Opts {
    #[clap(short, long, default_value = "/dev/ttyUSB0")]
    port: String,
    #[clap(short, long, default_value = "460800")]
    baud_rate: usize,
    #[clap(short, long, default_value = "8", possible_values = &["5", "6", "7", "8"])]
    char_size: u8,
    #[clap(short = 'P', long, default_value = "none", possible_values = &["none", "odd", "even"])]
    parity: String,
    #[clap(short, long, default_value = "1", possible_values = &["1", "2"])]
    stop_bits: u8,
    #[clap(short, long, default_value = "none", possible_values = &["none", "software", "hardware"])]
    flow_control: String,
}

fn main() -> Result<()> {
    let opts: Opts = Opts::parse();

    let port = Serial::new(
        &opts.port,
        &PortSettings {
            baud_rate: serial_embedded_hal::BaudRate::BaudOther(opts.baud_rate),
            char_size: match opts.char_size {
                5 => serial_embedded_hal::CharSize::Bits5,
                6 => serial_embedded_hal::CharSize::Bits6,
                7 => serial_embedded_hal::CharSize::Bits7,
                8 => serial_embedded_hal::CharSize::Bits8,
                _ => unreachable!(),
            },
            parity: match opts.parity.as_str() {
                "none" => serial_embedded_hal::Parity::ParityNone,
                "odd" => serial_embedded_hal::Parity::ParityOdd,
                "even" => serial_embedded_hal::Parity::ParityEven,
                _ => unreachable!(),
            },
            stop_bits: match opts.stop_bits {
                1 => serial_embedded_hal::StopBits::Stop1,
                2 => serial_embedded_hal::StopBits::Stop2,
                _ => unreachable!(),
            },
            flow_control: match opts.flow_control.as_str() {
                "none" => serial_embedded_hal::FlowControl::FlowNone,
                "software" => serial_embedded_hal::FlowControl::FlowSoftware,
                "hardware" => serial_embedded_hal::FlowControl::FlowHardware,
                _ => unreachable!(),
            },
        },
    )?;

    let (tx, rx) = port.split();
    let mut spidriver = SPIDriver::new(tx, rx);

    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input)?;

        let mut data = input.into_bytes();
        spidriver.transfer(&mut data);
    }

    Ok(())
}