#define UART_BAUD_RATE      9600

#include <stdlib.h>
#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "uart.h"
#include "i2cmaster.h"

char linebuffer[80];
char tmpbuffer[2] = " ";

char uart_recv()
{
    unsigned int c = UART_NO_DATA;

    while ( c & UART_NO_DATA )
        c = uart_getc(); // wait for data

    if ( c & UART_FRAME_ERROR )
        uart_puts_P("UART Frame Error: ");
    if ( c & UART_OVERRUN_ERROR )
        uart_puts_P("UART Overrun Error: ");
    if ( c & UART_BUFFER_OVERFLOW )
        uart_puts_P("Buffer overflow error: ");

    return c;
}

void discover()
{
    uart_puts_P("Discovering i2c devices...\r\n");

    for (uint16_t i = 16; i < 240; i=i+2)
    {
        uint8_t ret = i2c_start(i);

        if(!ret)
        {
            char tmp[8];
            itoa(i&(~1),tmp,16);
            uart_puts_P("Found device with adress: 0x");
            uart_puts(tmp);
            uart_puts_P("\r\n");
        }

        i2c_stop();
    }
}


void setAddress(uint8_t device_address, uint16_t memory_address)
{
    uint8_t ret = i2c_start(device_address + I2C_WRITE);
    if(ret)
    {
        i2c_stop();
        uart_puts_P("Writing failed.\r\n");
        return;
    }

    i2c_write(memory_address >> 8);
    i2c_write(memory_address);
}


void read(uint8_t device_address, uint16_t cnt)
{
    uint8_t ret = i2c_rep_start(device_address + I2C_READ);

    if(ret)
    {
        i2c_stop();
        uart_puts_P("Reading failed.\r\n");
        return;
    }

    for (uint16_t i = 0; i < cnt; ++i)
    {
        if(i%16 == 0)
            uart_puts_P("\r\n");

        ret = i2c_readAck();

        if(ret < 16)
            uart_putc('0');

        char tmp[8];
        itoa(ret,tmp,16);
        uart_puts(tmp);
        uart_putc(' ');
    }

    i2c_readNak();
    i2c_stop();
    uart_puts_P("\r\n\r\n");
}


void write(uint8_t device_address)
{
    uint8_t val = 0;
    uint16_t cnt = 0;
    while(1)
    {
        // receive a line
        linebuffer[0] = '\0';
        tmpbuffer[0] = '\0';
        while(tmpbuffer[0] != '\r')
        {
            tmpbuffer[0] = uart_recv();
            uart_putc(tmpbuffer[0]);
            strcat(linebuffer, tmpbuffer);
        }

        uart_putc('\n');

        if(linebuffer[0] == 'q')
            break;

        // parse line and write data
        char* end = linebuffer;
        while(end[0] != '\r')
        {
            val = strtoul(end, &end, 16);
            uint8_t err = i2c_write(val);
            if(err)
            {
                i2c_stop();
                uart_puts_P("Error while writing.\r\n");
                return;
            }
            ++cnt;
        }
    }

    i2c_stop();

    char tmp[8];
    itoa(cnt,tmp,16);
    uart_puts(tmp);
    uart_puts_P(" Bytes were written\r\n");
}


void sniff(uint8_t d_add, uint16_t count)
{
    TWAR = d_add & ~1;

    for(uint16_t i = 0; i < count; ++i)
    {
        // start twi interface
        TWCR = (1<<TWEA) | (1<<TWEN) | (1<<TWINT);

        while(!(TWCR & (1<<TWINT)));

        // check if receiving or transmitting
        if(TWSR == 0x60)
            uart_puts_P("receiving: ");
        else if(TWSR == 0xA8)
        {
            uart_puts_P("transmitting something\r\n");
            TWCR = (1<<TWINT);
            continue;
        }

        // if receiving, print the received bytes
        char tmp[3];
        while(TWSR != 0xA0)
        {
            TWCR = (1<<TWEN) | (1<<TWINT);

            while(!(TWCR & (1<<TWINT)));

            if(TWSR == 0x80 || TWSR == 0x88 )
            {
                itoa(TWDR,tmp,16);
                uart_puts(tmp);
                uart_putc(' ');
            }
        }

        uart_puts_P("\r\n");
    }

    TWAR = 0x00;
}

int main(void)
{
    DDRC = 0x00;
    PORTC &= ~(0x04);

    linebuffer[0] = '\0';

    uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
    i2c_init();

    sei();

    uart_putc('>');

    for(;;)
    {
        tmpbuffer[0] = uart_recv();
        uart_putc(tmpbuffer[0]);
        strcat(linebuffer, tmpbuffer);

        if(tmpbuffer[0] == '\r') // new line received
        {
            uart_putc('\n');

            if( strstr(linebuffer, "help") == linebuffer )
            {
                uart_puts_P("Available commands:\r\n");
                uart_puts_P("  discover - find devices on the bus\r\n");
                uart_puts_P("      read - read memory from an eeprom\r\n");
                uart_puts_P("     write - write data to an eeprom\r\n");
                uart_puts_P("     sniff - monitor the bus\r\n");
            }
            else if( strstr(linebuffer, "discover") == linebuffer )
            {
                DDRC |= 0x04; // mute other masters on bus
                _delay_ms(100);

                discover();

                DDRC &= ~(0x04);
            }
            else if( strstr(linebuffer, "read ") == linebuffer )
            {
                DDRC |= 0x04; // mute other masters on bus
                _delay_ms(100);

                char* end = linebuffer + 5;
                uint8_t d_add = strtoul(end, &end, 16);
                uint16_t m_add = strtoul(end, &end, 16);
                uint16_t cnt = strtoul(end, &end, 10);

                setAddress(d_add, m_add);
                read(d_add, cnt);

                DDRC &= ~(0x04);
            }
            else if( strstr(linebuffer, "write ") == linebuffer )
            {
                DDRC |= 0x04; // mute other masters on bus

                _delay_ms(100);

                char* end = linebuffer + 6;
                uint8_t d_add = strtoul(end, &end, 16);
                uint16_t m_add = strtoul(end, &end, 16);

                setAddress(d_add, m_add);
                write(d_add);

                DDRC &= ~(0x04);
            }
            else if( strstr(linebuffer, "sniff ") == linebuffer )
            {
                char* end = linebuffer + 6;
                uint8_t d_add = strtoul(end, &end, 16);
                uint16_t count = strtoul(end, &end, 10);
                sniff(d_add, count);
            }
            else
                uart_puts_P("Unknown command\r\n");

            linebuffer[0] = '\0';
            uart_putc('>');
        }
    }
}