/******************************************************************************/
/* Files to Include                                                           */
/******************************************************************************/

#include <stdint.h>        /* For uint8_t definition */
#include <stdbool.h>       /* For true/false definition */

#include "user.h"          /* User funct/params, such as InitApp */

#include "ws2811.h"
#include "serial.h"


/******************************************************************************/
/* User Global Variable Declaration                                           */
/******************************************************************************/

/* i.e. uint8_t <variable_name>; */


void RGBWheel(uint16_t pos, uint8_t *r, uint8_t *g, uint8_t *b)
{
    switch (pos / 128)
    {
        case 0:
            *r = (127 - pos % 128);
            *g = pos % 128;
            *b = 0;
            break;
        case 1:
            *g = (127 - pos % 128);
            *b = pos % 128;
            *r = 0;
            break;
        case 2:
            *b = 127 - pos % 128;
            *r = pos % 128;
            *g = 0;
            break;
    }
}

/* connect Fixed Voltage Reference to A2D convertor
 * input, set Vdd as reference, read value.
 *  (val / 1024) * Vref == Vdd
 */
bool test_battery(void)
{
    uint16_t volt;
    // read battery
    // Read Vdd by sampling FVR
    FVRCONbits.ADFVR = 0b10;    // 2.048v // 1.024v
    FVRCONbits.FVREN = 1;       // enable
    while (!FVRCONbits.FVRRDY) {};  // wait for it to stabilise

    ADCON1bits.ADCS = 0b110;    // slowest sample clock
    ADCON1bits.ADFM = 1;        // right justify
    ADCON0bits.CHS = 0b11111;   // FVR input
    ADCON1bits.ADPREF = 0b00;   // +ve ref Vdd
    ADCON0bits.ADON = 1;        // enable ADC

    ADCON0bits.GO = 1;          // start conversion
    while (ADCON0bits.GO) {};   // wait til finished

    volt = (ADRESH << 8) | ADRESL;

    // 3.0 V is >= 0x02BB
    if (volt >= 0x02BB) {
        unsigned char i;
        unsigned char *p;

        // first pixel faint red, rest black
        // battery below 3.0v
        p = rgbdata;
        for (i=0; i<RGB_COUNT; i++) *p++=0;
        p = rgbdata;
        p++;
        *p = 0x08;

        ws2811_transmit();
        return true;
    }
    return false;
}

#ifdef SMALL_RAND
static uint8_t random_byte = 0xB4;

/* generate a random number */
uint8_t dorand(void)
{
    asm("BCF STATUS,0");
    asm("RRF _random_byte,W");
    asm("BTFSC STATUS,0");
    asm("XORLW 0xB4");
    asm("MOVWF _random_byte");

    return random_byte;
}
#else
uint16_t dorand(void)
{
    static uint16_t lfsr = 0xACE1u;
    lfsr = (lfsr >> 1) ^ (-(lfsr & 1u) & 0xB400u);

    return lfsr;
}

#endif

#define CHECK_MSEC 5        // sample key every 5 mS
#define PRESS_MSEC 10       // stable before presses
#define RELEASE_MSEC 100    // stable before released


/* test to see if the button has been pressed */
bool test_button(void)
{
    static bool down = false;
    static uint8_t count = PRESS_MSEC / CHECK_MSEC;

    // button was up
    if (!down) {
        if (PORTAbits.RA1 == 0)
            count--;
        else
            count = PRESS_MSEC / CHECK_MSEC;
        // has been down for the count, flip state
        if (count <= 0) {
            down = true;
            count = RELEASE_MSEC / CHECK_MSEC;
        }
    } else {
        if (PORTAbits.RA1 == 1)
            count--;
        else
            count = RELEASE_MSEC / CHECK_MSEC;
        // has been back up for the count
        // flip state, and say we saw one cycle
        if (count <= 0) {
            down = false;
            count = PRESS_MSEC / CHECK_MSEC;
            return true;
        }
    }
    return false;
}


void clear_all(void)
{
    unsigned char i;
    /* blank everything */
    for (i=0; i<RGB_COUNT; i++) rgbdata[i]=0;
}

/* how much rainbow to show 0-384 */
static const uint32_t quant = 384; //200;

bool rainbow_draw(void)
{
    unsigned char r,g,b;
    unsigned char *p;
    unsigned char i;

    /* draw a rainbow */
    p = rgbdata;
    for (i=0; i<16; i++) {
        RGBWheel((i * quant / 16) % 384, &r, &g, &b);
        *(p++) = g/4;
        *(p++) = r/4;
        *(p++) = b/4;
    }
    for (i=16; i>0; i--) {
        RGBWheel(((i-1) * quant / 16) % 384, &r, &g, &b);
        *(p++) = g/4;
        *(p++) = r/4;
        *(p++) = b/4;
    }
    return true;
}

#define RAIN_UNIT 5
unsigned char rain_delay = RAIN_UNIT;

bool rainbow_rotate(void)
{
    static unsigned char delay = 0;

    unsigned char r,g,b;
    unsigned char *p;
    unsigned char i;
    unsigned char t;

    if ((delay--) > 0) return false;

    // rotate the colours
    p = rgbdata;

    g = p[0];
    r = p[1];
    b = p[2];

    for (i=0; i<15*3; i++) {
        *p = *(p+3);
        p++;
    }
    *(p++) = g;
    *(p++) = r;
    *(p++) = b;

    // left eye, other direction

    p += 15 * 3;
    g = p[0];
    r = p[1];
    b = p[2];
    p += 2;
    for (i=0; i<15*3; i++) {
        *p = *(p-3);
        p--;
    }
    *(p--) = b;
    *(p--) = r;
    *(p--) = g;
    
    delay = rain_delay;
    return true;
}


/******
 colour bouncing blobs mode
 */

int8_t rspeed, gspeed, bspeed;
#define MAX_SPEED 30;
#define MAX_LEN 8
#define MAX_BRIGHT 32

bool bouncer_draw(void)
{
    clear_all();

    rspeed = dorand() % MAX_SPEED;
    gspeed = dorand() % MAX_SPEED;
    bspeed = dorand() % MAX_SPEED;

    unsigned char i;
    // draw rand len red
    for (i=(dorand() % MAX_LEN)+1; i>0; i--) {
        rgbdata[(3*i)+1] = MAX_BRIGHT;
    }
    // draw rand len green
    for (i=(dorand() % MAX_LEN)+1; i>0; i--) {
        rgbdata[(3*i)] = MAX_BRIGHT;
    }
    // draw rand len blue
    for (i=(dorand() % MAX_LEN)+1; i>0; i--) {
        rgbdata[(3*i)+2] = MAX_BRIGHT;
    }
    
    return true;
}

bool bouncer_rotate(uint8_t loop)
{
    unsigned char * p;
    unsigned char i;

    if (loop % rspeed == 0) {
        if (rspeed > 0 ) {
            // moving up
            if (rgbdata[ (LED_COUNT-1)*3+1 ] == 0) {
                // still space to move up
                p = rgbdata + RGB_COUNT - 5;
                for (i=LED_COUNT-1; i > 0; i--) {
                    p[3] = *p;
                    p-=3;
                }
                rgbdata[1] = 0;
            } else {
                rspeed = -rspeed;
            }
        } else {
            // moving down
            if (rgbdata[1] == 0 || (rgbdata[1]!=0 && rgbdata[4]!=0)) {
                // still space to move down
                p = rgbdata + 1;
                for (i=LED_COUNT-1; i>0; i++) {
                    *p = p[3];
                    p+=3;
                }
                rgbdata[RGB_COUNT-2] = 0;
            } else {
                rspeed = dorand() % MAX_SPEED;
                for (i=(dorand() % MAX_LEN)+1; i>0; i--) {
                    rgbdata[(3*i)+1] = MAX_BRIGHT;
                }
            }
        }
    }
    if (loop % gspeed == 0) {
        if (gspeed > 0 ) {
            // moving up
            if (rgbdata[ (LED_COUNT-1)*3 ] == 0) {
                // still space to move up
                p = rgbdata + RGB_COUNT - 6;
                for (i=LED_COUNT-1; i > 0; i--) {
                    p[3] = *p;
                    p-=3;
                }
                rgbdata[0] = 0;
            } else {
                gspeed = -gspeed;
            }
        } else {
            // moving down
            if (rgbdata[0] == 0 || (rgbdata[0]!=0 && rgbdata[3]!=0)) {
                // still space to move down
                p = rgbdata;
                for (i=LED_COUNT-1; i>0; i++) {
                    *p = p[3];
                    p+=3;
                }
                rgbdata[RGB_COUNT-3] = 0;
            } else {
                gspeed = dorand() % MAX_SPEED;
                // draw rand len green
                for (i=(dorand() % MAX_LEN)+1; i>0; i--) {
                    rgbdata[(3*i)] = MAX_BRIGHT;
                }
            }
        }
    }
    if (loop % bspeed == 0) {
        if (bspeed > 0 ) {
            // moving up
            if (rgbdata[ (LED_COUNT-1)*3+2 ] == 0) {
                // still space to move up
                p = rgbdata + RGB_COUNT - 4;
                for (i=LED_COUNT-1; i > 0; i--) {
                    p[3] = *p;
                    p-=3;
                }
                rgbdata[2] = 0;
            } else {
                bspeed = -bspeed;
            }
        } else {
            // moving down
            if (rgbdata[2] == 0 || (rgbdata[2]!=0 && rgbdata[5]!=0)) {
                // still space to move down
                p = rgbdata + 2;
                for (i=LED_COUNT-1; i>0; i++) {
                    *p = p[3];
                    p+=3;
                }
                rgbdata[RGB_COUNT-1] = 0;
            } else {
                bspeed = dorand() % MAX_SPEED;
                // draw rand len blue
                for (i=(dorand() % MAX_LEN)+1; i>0; i--) {
                    rgbdata[(3*i)+2] = MAX_BRIGHT;
                }
            }
        }
    }

    return true;
}

/* fade in and out mode */
bool glow_draw(uint8_t r, uint8_t g, uint8_t b)
{
    rspeed = r / 8;
    gspeed = g / 8;
    bspeed = b / 8;
    
    return false;
}

bool glow_rotate(uint8_t loop)
{
    unsigned char *p;
    unsigned char i;
    
    uint8_t val = loop & 0x7F;

    if (loop >= 128)
        val = 128 - val;

    val /= 2;  /* range is now 0-63 */

    uint8_t r,g,b;
    g = (uint16_t)gspeed * val / 64;
    r = (uint16_t)rspeed * val / 64;
    b = (uint16_t)bspeed * val / 64;

    /* draw a rainbow */
    p = rgbdata;
    for (i=0; i<LED_COUNT; i++) {
        *(p++) = g;
        *(p++) = r;
        *(p++) = b;
    }

    return true;
}

bool dot_draw(uint8_t r, uint8_t g, uint8_t b)
{
    uint8_t i;
    uint8_t *p = rgbdata;
    for (i=0; i<RGB_COUNT;i++) *(p++)=0;
    
    rgbdata[0] = g / 8;
    rgbdata[1] = r / 8;
    rgbdata[2] = b / 8;
    rgbdata[48+0] = g / 8;
    rgbdata[48+1] = r / 8;
    rgbdata[48+2] = b / 8;

    return false;
}

/******************************************************************************/
/* Main Program                                                               */
/******************************************************************************/

#define MAX_MODE 8




void main(void)
{
    unsigned char mode = 2;
    bool changed = false;
    uint8_t loop = 0;
    
    /* Initialize I/O and Peripherals for application */
    InitApp();
    ws2811_init();

    /* initial pattern */
    rainbow_draw();
    ws2811_transmit();

    glow_draw(0,255,0);
    
    /* main loop */
    while(1)
    {
        CLRWDT(); // tell watchdog we are still awake

        /* test if the battery is dead, stop if it is */
        if (test_battery()) {
            SLEEP();
        }

        /* if button is pressed, change mode */
        if (test_button()) {
            mode = (mode + 1) % MAX_MODE;
            loop = 0;

            // initialise the new mode
            switch (mode) {
                case 0:
                    rain_delay = RAIN_UNIT;
                    changed = rainbow_draw();
                    break;
                case 1:
                    changed = bouncer_draw();
                    break;
                case 2:
                    changed = glow_draw(0,255,0);
                    break;
                case 3:
                    changed = glow_draw(255,0,0);
                    break;
                case 4:
                    changed = glow_draw(0,0,255);
                    break;
                case 5:
                    changed = glow_draw(255,0,255);
                    break;
                case 6:
                    changed = dot_draw(255,255,255);
                    break;
                case 7:
                    changed = dot_draw(0,8,0);
                    break;
            }
        } else {
            /* otherwise run mode maintenance */
            switch (mode) {
                case 0:
                    changed = rainbow_rotate();
                    break;
                case 1:
                    changed = bouncer_rotate(loop);
                    break;
                case 2:
                case 3:
                case 4:
                    changed = glow_rotate(loop);
                    break;
                case 5:
                    if (loop == 0) {
                        uint16_t n = dorand() % quant;
                        uint8_t r,g,b;
                        RGBWheel(n, &r, &g, &b);
                        changed = glow_draw(r, g, b);
                    }
                    changed = glow_rotate(loop);
                    break;
                case 6:
                    changed = rainbow_rotate();
                    break;
                case 7:
                    if (loop==0) changed = rainbow_rotate();
                    break;
            }
        }

        /* transmit the latest data set */
        if (changed) ws2811_transmit();

        /* wait a bit */
        __delay_ms(5);

        loop++;
    }
}