use libboard_artiq::pl::csr;
use libcortex_a9::cache;
use libboard_artiq::drtioaux_proto::ANALYZER_MAX_SIZE;

const BUFFER_SIZE: usize = 512 * 1024;

#[repr(align(64))]
struct Buffer {
    data: [u8; BUFFER_SIZE],
}

static mut BUFFER: Buffer = Buffer {
    data: [0; BUFFER_SIZE]
};

fn arm() {
    unsafe {
        let base_addr = &mut BUFFER.data[0] as *mut _ as usize;
        let last_addr = &mut BUFFER.data[BUFFER_SIZE - 1] as *mut _ as usize;
        csr::rtio_analyzer::dma_base_address_write(base_addr as u32);
        csr::rtio_analyzer::message_encoder_overflow_reset_write(1);
        csr::rtio_analyzer::dma_last_address_write(last_addr as u32);
        csr::rtio_analyzer::dma_reset_write(1);
        csr::rtio_analyzer::enable_write(1);
    }
}

fn disarm() {
    unsafe {
        csr::rtio_analyzer::enable_write(0);
        while csr::rtio_analyzer::busy_read() != 0 {}
        cache::dcci_slice(&BUFFER.data);
    }
}

pub struct Analyzer {
    // necessary for keeping track of sent data
    sent_bytes: usize,
    data_iter: usize
}

pub struct Header {
    pub total_byte_count: u64,
    pub sent_bytes: u32,
    pub error: bool
}

pub struct AnalyzerSliceMeta {
    pub len: u16,
    pub last: bool
}

impl Analyzer {
    pub fn new() -> Analyzer {
        // create and arm new Analyzer
        arm();
        Analyzer {
            sent_bytes: 0,
            data_iter: 0
        }
    }

    fn drop(&mut self) {
        disarm();
    }

    pub fn get_header(&mut self) -> Header {
        disarm();

        let overflow = unsafe { csr::rtio_analyzer::message_encoder_overflow_read() != 0 };
        let bus_err = unsafe { csr::rtio_analyzer::dma_bus_error_read() != 0 };
        let total_byte_count = unsafe { csr::rtio_analyzer::dma_byte_count_read() as u64 };
        let wraparound = total_byte_count >= BUFFER_SIZE as u64;
        self.sent_bytes = if wraparound { BUFFER_SIZE } else { total_byte_count as usize };
        self.data_iter = if wraparound { (total_byte_count % BUFFER_SIZE as u64) as usize } else { 0 };
        
        if overflow {
            warn!("overflow occured");
        }
        if bus_err {
            warn!("bus error occured");
        }
        
        Header {
            total_byte_count: total_byte_count,
            sent_bytes: self.sent_bytes as u32,
            error: overflow | bus_err
        }
    }

    pub fn get_data(&mut self, data_slice: &mut [u8; ANALYZER_MAX_SIZE]) -> AnalyzerSliceMeta {
        let data = unsafe { &BUFFER.data[..] };
        let i = self.data_iter;
        let len = if i + ANALYZER_MAX_SIZE < self.sent_bytes { ANALYZER_MAX_SIZE } else { self.sent_bytes - i };
        let last = i + len == self.sent_bytes;
        if i + len >= BUFFER_SIZE {
            data_slice[..len].clone_from_slice(&data[i..BUFFER_SIZE]);
            data_slice[..len].clone_from_slice(&data[..(i+len) % BUFFER_SIZE]);
        } else {
            data_slice[..len].clone_from_slice(&data[i..i+len]);
        }
        self.data_iter += len;

        if last {
            arm();
        }
        
        AnalyzerSliceMeta {
            len: len as u16,
            last: last
        }
    }
}