#include <avr/io.h>
#include <avr/interrupt.h>
#include "radio.h"
#include "radio_addr.h"
#include "led_driver.h"
#include "controller.h"
#include "messages.h"
#include "controller_input.h"
#include "controls.h"

unsigned char current_level=1;
unsigned char current_player=RADIO_ADDR_NULL;
unsigned char resetting=1;
unsigned char game_over=1;

unsigned char aiming=0;
unsigned char aim_remaining=0;
unsigned char shots_taken=0;

unsigned int display_value=0x00;
unsigned char display_dir=0;
unsigned char display_type=DISP_TYPE_NONE;
unsigned char display_iter=0;

unsigned char rec_src,rec_len;
unsigned char rec_buffer[RADIO_BUFFER_SIZE];

unsigned char aim_timer=0;
unsigned char laser_timer=TIMER_8_OFF;
unsigned int reset_timer=TIMER_OFF;
unsigned char input_timer=INPUT_UPDATE_TIMEOUT;
unsigned int led_timer=0,led_rate=500;
unsigned int display_timer=0;

void initialize(void);
void process_packet(void);
void reset(void);
void set_display_type(unsigned char type);
void set_display_timer(void);
void update_display(void);
void set_display_timer(void);
inline void set_display(unsigned int value);

int main(void)
{
    signed char ret;
    unsigned char data[RADIO_BUFFER_SIZE]={0};
    unsigned char button_state=0x00;

    initialize();
    set_display_type(DISP_TYPE_WINNER);

    while(1)
    {
        radio_exec();
        ret=radio_receive(&rec_src,&rec_len,rec_buffer);
        if(ret==RET_RX_PACKET_REC)process_packet();

        //Check Controller Input
        if(input_timer==0)
        {
            input_timer=INPUT_UPDATE_TIMEOUT;
            ret=controller_input_get();

            //Was reset pressed?
            if(ret&CONTROL_RESET && !(button_state&CONTROL_RESET))
            {
                resetting=1;
                reset_timer=RESET_TIMEOUT;
                set_display_type(DISP_TYPE_RESET);
            }
            else if(!(ret&CONTROL_RESET) && button_state&CONTROL_RESET)
            {
                if(resetting)
                {
                    resetting=0;
                    reset_timer=TIMER_OFF;
                    set_display_type(DISP_TYPE_NONE);
                }
            }

            //Is the game running?
            if(!game_over)
            {
                //Are we aiming?
                if(ret&CONTROL_AIM && !(button_state&CONTROL_AIM) &&
                   current_player==RADIO_DEV_ADDR)
                {
                    if(aim_remaining>0)
                    {
                        aiming=1;
                        LASER_ON;
                        set_display_type(DISP_TYPE_NONE);
                        aim_timer=AIM_TICK_TIMEOUT;
                    }
                }
                else if(!(ret&CONTROL_AIM) && button_state&CONTROL_AIM)
                {
                    aiming=0;
                    LASER_OFF;
                }

                //Are we aiming?
                if(aiming&&aim_timer==0)
                {
                    aim_timer=AIM_TICK_TIMEOUT;
                    if(aim_remaining>0)aim_remaining--;
                    set_display(aim_remaining);
                    //Are we done aiming?
                    if(aim_remaining==0)
                    {
                        aiming=0;
                        LASER_OFF;
                    }
                }

                //Are we firing?
                if(ret&CONTROL_FIRE && !(button_state&CONTROL_FIRE)&&
                   shots_taken<current_level&&
                   current_player==RADIO_DEV_ADDR)
                {
                    data[LB_POS_MSG_TYPE]=LB_MSG_FIRE;
                    data[LB_POS_DATA]=aim_remaining;
                    radio_send(RADIO_ADDR_BOARD,1,2,data);//Send fire report.
                    shots_taken++;
                    aim_remaining=shots_taken<current_level?10:0;
                    laser_timer=LASER_FLASH_TIMEOUT;
                    LASER_ON;
                    set_display(aim_remaining);
                }
            }

            button_state=ret;
        }

        //Update Display
        if(display_timer==0)
        {
            set_display_timer();
            update_display();
        }

        if(laser_timer==0)
        {
            LASER_EN=LASER_OFF;
            laser_timer=TIMER_8_OFF;
        }

        if(resetting&&
           reset_timer==0)
        {
            reset_timer=TIMER_OFF;
            resetting=0;
            reset();
            data[LB_POS_MSG_TYPE]=LB_MSG_RESET;
            radio_send(RADIO_ADDR_BOARD,1,1,data);//Send reset.
            radio_send(RADIO_ADDR_OPPONENT,1,1,data);//Send reset.
        }

        if(led_timer==0)
        {
            led_timer=led_rate;//500;
            #if defined(__AVR_ATmega8__)||defined(__AVR_ATmega48__)
            PORTD^=1<<PD4;
            #else
            PORTA^=1<<PA04;
            #endif
        }
    }
    return 0;
}

void initialize(void)
{
    #if defined(__AVR_ATmega32__)
    //Setup timer 0 with 1ms period.
    TIMSK=0x02;//Enable output compare interrupt.
    TCCR0=0x03;//Set 1:64 clock.
    OCR0=249;//250 ticks @ 250 kHz = 1 ms.
    #elif defined(__AVR_AT90S8515__)
    //Setup timer 1 with 1ms period.
    TIMSK=0x40;//Enable output compare interrupt.
    TCCR1B=0x0A;//Enable reset on compare match, 1:8 clock.
    OCR1A=500;//500 ticks @ 500 kHz = 1 ms.
    #elif defined(__AVR_ATmega8__)
    TIMSK=0x10;//Enable output compare interrupt.
    TCCR1B=0x0A;//Enable reset on compare match, 1:8 clock.
    OCR1A=500;//500 ticks @ 500 kHz = 1 ms.
    #elif defined(__AVR_ATmega48__)
    TIMSK1=0x02;//Enable output compare interrupt.
    TCCR1B=0x0A;//Enable reset on compare match, 1:8 clock.
    //500 ticks @ 500 kHz = 1 ms.
    OCR1AH=1;
    OCR1AL=244;
    #endif

    //Diagnostic LED.
    #if defined(__AVR_ATmega8__)||defined(__AVR_ATmega48__)
    DDRD|=1<<DDD4;
    PORTD|=1<<PD4;
    #else
    DDRA=0xFF;
    PORTA=0xFF;
    #endif

    //Enable NES power.
    DDRB|=1<<DDB0;
    PORTB|=1<<PB0;

    LASER_DDR|=1<<LASER_PIN;
    LASER_OFF;

    radio_init();
    led_init();
    controller_input_init();

    led_set(0);

    sei();
}

void process_packet(void)
{
    switch(rec_buffer[LB_POS_MSG_TYPE])
    {
    case LB_MSG_HIT_REPORT:
        if(rec_buffer[LB_POS_DATA]==LB_DATA_HIT)set_display_type(DISP_TYPE_HIT);
        else set_display_type(DISP_TYPE_MISS);
        break;
    case LB_MSG_GAME_OVER:
        game_over=1;//Disable controls until reset.
        aim_remaining=0;
        if(rec_buffer[LB_POS_DATA]==RADIO_DEV_ADDR)set_display_type(DISP_TYPE_WINNER);
        else if(rec_buffer[LB_POS_DATA]==RADIO_ADDR_NULL)set_display_type(DISP_TYPE_TIE);
        else set_display_type(DISP_TYPE_LOSER);
        break;
    case LB_MSG_RESET:
        reset();
        break;
    case LB_MSG_PLAYER:
        current_player=rec_buffer[LB_POS_DATA];
        shots_taken=0;
        if(current_player==RADIO_DEV_ADDR)aim_remaining=10;
    	  set_display(aim_remaining);
        break;
    case LB_MSG_LEVEL:
        current_level=rec_buffer[LB_POS_DATA];
        break;
    default: break;
    }
}

void reset(void)
{
    set_display_type(DISP_TYPE_NONE);
    aim_remaining=0;
    aiming=0;
    shots_taken=0;
    current_level=1;
    current_player=RADIO_ADDR_NULL;
    game_over=0;
    set_display(aim_remaining);
    set_display_type(DISP_TYPE_WINNER);
}

void set_display_type(unsigned char type)
{
    display_type=type;
    switch(type)
    {
    case DISP_TYPE_WINNER:
    case DISP_TYPE_TIE:
        display_value=DISP_START_WINNER;
        display_iter=DISP_ITER_WINNER;
        break;
    case DISP_TYPE_LOSER:
        display_value=DISP_START_LOSER;
        display_iter=DISP_ITER_LOSER;
        display_dir=0;
        break;
    case DISP_TYPE_HIT:
        display_value=DISP_START_HIT;
        display_iter=DISP_ITER_HIT;
        break;
    case DISP_TYPE_MISS:
        display_value=DISP_START_MISS;
        display_iter=DISP_ITER_MISS;
        break;
    case DISP_TYPE_RESET:
        display_value=DISP_START_RESET;
        display_iter=DISP_ITER_RESET;
        break;
    case DISP_TYPE_NONE:
    default:
        display_type=DISP_TYPE_NONE;
        display_value=0;
        display_iter=0;
        break;
    }
    if(display_type!=DISP_TYPE_NONE)led_set(display_value);//Set display value.
    else set_display(aim_remaining);
    set_display_timer();
}

void set_display_timer(void)
{
    switch(display_type)
    {
    case DISP_TYPE_WINNER:
    case DISP_TYPE_TIE:
        display_timer=DISP_TIMEOUT_WINNER;
        break;
    case DISP_TYPE_LOSER:
        display_timer=DISP_TIMEOUT_LOSER;
        break;
    case DISP_TYPE_HIT:
        display_timer=DISP_TIMEOUT_HIT;
        break;
    case DISP_TYPE_MISS:
        display_timer=DISP_TIMEOUT_MISS;
        break;
    case DISP_TYPE_RESET:
        display_timer=DISP_TIMEOUT_RESET;
        break;
    case DISP_TYPE_NONE:
    default:
        display_timer=TIMER_OFF;
        break;
    }
}

void update_display(void)
{
    //Are we done with the current mode?
    if(display_iter==0||((--display_iter)==0))
    {
        set_display_type(DISP_TYPE_NONE);
        return;
    }
    switch(display_type)
    {
    case DISP_TYPE_WINNER:
    case DISP_TYPE_TIE:
        display_value=~display_value;
        break;
    case DISP_TYPE_LOSER:
        if(!display_dir)display_value>>=1;
        else display_value=display_value<<1|0x01;
        if(display_value==0)display_dir=!display_dir;
        break;
    case DISP_TYPE_HIT:
        display_value<<=1;
        break;
    case DISP_TYPE_MISS:
        if(display_iter==3)display_value=0x070;
        else if(display_iter==2)display_value=0x180;
        else if(display_iter==1)display_value=0x200;
        break;
    case DISP_TYPE_RESET:
        display_value<<=1;
        display_value|=0x01;
        break;
    case DISP_TYPE_NONE:
    default:
        break;
    }
    led_set(display_value);//Set display value.
}

inline void set_display(unsigned int value)
{
    unsigned int led;
    led=(1<<value)-1;
    led_set(led);
}

#if defined(__AVR_ATmega32__)
ISR(TIMER0_COMP_vect)
#else
ISR(TIMER1_COMPA_vect)
#endif
{
    if(radio_tx_timer!=RADIO_TIMER_OFF&&radio_tx_timer>0)radio_tx_timer--;
    if(radio_rx_timer!=RADIO_TIMER_OFF&&radio_rx_timer>0)radio_rx_timer--;

    if(aim_timer>0)aim_timer--;
    if(laser_timer!=TIMER_8_OFF&&laser_timer>0)laser_timer--;
    if(reset_timer!=TIMER_OFF&&reset_timer>0)reset_timer--;
    if(input_timer>0)input_timer--;

    if(led_timer>0)led_timer--;
    if(display_timer!=TIMER_OFF&&display_timer>0)display_timer--;
}