use devices::DeviceImpl;

use std;
use slog::Logger;

const USART_DATA: u32 = 0;
const USART_STATUS: u32 = 1;
const USART_CTRLA: u32 = 3;
const USART_CTRLB: u32 = 4;
const USART_CTRLC: u32 = 5;
const USART_BAUDCTRLA: u32 = 6;
const USART_BAUDCTRLB: u32 = 7;

pub struct USART {
    /*
    0x8A0: 'USARTC0_DATA',
    0x8A1: 'USARTC0_STATUS',
    0x8A3: 'USARTC0_CTRLA',
    0x8A4: 'USARTC0_CTRLB',
    0x8A5: 'USARTC0_CTRLC',
    0x8A6: 'USARTC0_BAUDCTRLA',
    0x8A7: 'USARTC0_BAUDCTRLB',
    */
    log: Logger,
    // Raw values:
    status: u8,
    ctrla: u8,
    ctrlb: u8,
    ctrlc: u8,
    baudctrla: u8,
    baudctrlb: u8,
}

impl USART {
    pub fn new(log: Logger) -> Self {
        Self {
            log: log,
            status: 0,
            ctrla: 0,
            ctrlb: 0,
            ctrlc: 0,
            baudctrla: 0,
            baudctrlb: 0,
        }
    }
}

impl DeviceImpl for USART {
    fn read(&mut self, addr: u32) -> u8 {
        match addr {
            USART_DATA => {
                info!(self.log, "USART::Read(), not implemented");
                0
            },
            USART_STATUS => {
                // USART_DREIF_bm 0x20
                /*

                6528 #define USART_RXCIF_bm  0x80   // Receive Interrupt Flag bit mask.
                6529 #define USART_RXCIF_bp  7   // Receive Interrupt Flag bit position.
                6530
                6531 #define USART_TXCIF_bm  0x40   // Transmit Interrupt Flag bit mask.
                6532 #define USART_TXCIF_bp  6   // Transmit Interrupt Flag bit position.
                6533
                6534 #define USART_DREIF_bm  0x20   // Data Register Empty Flag bit mask.
                6535 #define USART_DREIF_bp  5   // Data Register Empty Flag bit position.
                6536
                6537 #define USART_FERR_bm  0x10   // Frame Error bit mask.
                6538 #define USART_FERR_bp  4   // Frame Error bit position.
                6539
                6540 #define USART_BUFOVF_bm  0x08   // Buffer Overflow bit mask.
                6541 #define USART_BUFOVF_bp  3   // Buffer Overflow bit position.
                6542
                6543 #define USART_PERR_bm  0x04   // Parity Error bit mask.
                6544 #define USART_PERR_bp  2   // Parity Error bit position.
                6545
                6546 #define USART_RXB8_bm  0x01   // Receive Bit 8 bit mask.
                6547 #define USART_RXB8_bp  0   // Receive Bit 8 bit position.
                6548
                 */
                info!(self.log, "Checking USART status");
                self.status | 0x20u8  // Data register empty flag.
            }
            USART_CTRLA => self.ctrla,
            USART_CTRLB => self.ctrlb,
            USART_CTRLC => self.ctrlc,
            USART_BAUDCTRLA => self.baudctrla,
            USART_BAUDCTRLB => self.baudctrlb,
            _ => unreachable!()
        }
    }

    fn write(&mut self, addr: u32, value: u8) {
        match addr {
            USART_DATA => {
                info!(self.log, "USART::Write({} / {:?})", value, std::char::from_u32(u32::from(value)));
            },
            USART_STATUS => self.status = value,
            USART_CTRLA => self.ctrla = value,
            USART_CTRLB => self.ctrlb = value,
            USART_CTRLC => self.ctrlc = value,
            USART_BAUDCTRLA => self.baudctrla = value,
            USART_BAUDCTRLB => self.baudctrlb = value,
            _ => panic!("Write to usart offset {} <- {:02X}", addr, value),
        }
    }
}