#include "magstripe.h"
#include <avr/interrupt.h>
#include "board.h"
#include "debug.h"
#include "timer.h"
#include <util/delay.h>
#include "util.h"
#include "config.h"
#include "avr_task.h"
#include <avr/sleep.h>
#include "string.h"
#include "avr_cunit.h"
#include "uart.h"
//#include "kbd.h"

//#undef _DBG
//#define _DBG


struct avrDataStruct *avrDataPtr;

struct trackVar
{
WORD cnt;
DWORD tmp;
WORD prev;
BYTE last_data;
WORD allBitCnt;
BYTE bitCnt8;
WORD byteCntRaw;
WORD dataCnt;
};

struct trackVar t2Var;
struct trackVar t1Var;

#define BCD_BIT_PER_CHAR 4
#define BCD_BUFFER_SIZE 50

#define BAD_CHAR 0xff

#define ALPHA_BIT_PER_CHAR 6
#define ALPHA_BUFFER_SIZE 110


BYTE buffer[GLOBAL_BUFFER_SIZE];

BYTE bcdRaw[BCD_BUFFER_SIZE];
//BYTE bcdDecoded[BCD_BUFFER_SIZE];

BYTE alphaRaw[ALPHA_BUFFER_SIZE];
//BYTE alphaDecoded[ALPHA_BUFFER_SIZE];

//BCD SS ES RLC ALPHA SS ES RLC
BYTE dataDecoded[ALPHA_BUFFER_SIZE+BCD_BUFFER_SIZE];

static inline void f2f(WORD tc, struct trackVar *tVar, BYTE *rawDest, WORD rawCnt);
BOOL decode(BYTE *raw_src, WORD bitCnt, BYTE *dest, WORD *bytesCnt, BYTE bitPerChar,
BYTE *parityArr, BYTE startSentinel, BYTE endSentinel);
static BYTE getBit(BYTE *bytePtr, WORD bitIndx);
static void bitsRever(BYTE *src, WORD cnt);

static BYTE parity4[16]= {1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1};
static BYTE parity6[64]= {1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1,
0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
0,1,1,0,1,0,0,1,1,0,0,1,0,1,1,0,
1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1};
//static BYTE bitcount4[16]={0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};



void track2_init()//BCD data INT0
{
cbi(TRACK2_DDR,TRACK2_PIN); //set track 2 pin as input

EIMSK |= _BV(INT0);
EICRA |= _BV(ISC00); // Any logical changes on INT1

// GICR |= _BV(TRACK2_INT);
// MCUCR |= _BV(ISC00); //Any logical changes on INT0
}

void track1_init()//ALPHA data INT1
{
cbi(TRACK1_DDR,TRACK1_PIN); //set track 1 pin as input

EIMSK |= _BV(INT1);
EICRA |= _BV(ISC10); // Any logical changes on INT1

// GICR |= _BV(TRACK1_INT);
// MCUCR |= _BV(ISC10); //Any logical changes on INT0
}

ISR(TIMER0_OVF_vect)//approximately every 35 ms
{
static BYTE cnt=0;
if(++cnt < 17) return;
cnt=0;

BYTE t1=0,t2=0;
//_DBG("TIMER0\n");
//track 2 BCD
if(t2Var.allBitCnt>0)
{
_DBG("DECODING BCD\n");
if(!decode(bcdRaw, t2Var.allBitCnt, dataDecoded+0,&t2Var.dataCnt,BCD_BIT_PER_CHAR,
parity4,BCD_START_SENTINEL,BCD_END_SENTINEL))
{
bitsRever(bcdRaw,t2Var.allBitCnt);
if(!decode(bcdRaw, t2Var.allBitCnt, dataDecoded+0,&t2Var.dataCnt,BCD_BIT_PER_CHAR,
parity4,BCD_START_SENTINEL,BCD_END_SENTINEL))
_DBG("BCD Error\n");
else t2=1;
}
else t2=1;
}

//track 1 ALPHA
if(t2)
if(t1Var.allBitCnt>0)
{
_DBG("DECODING ALPHA\n"); //offset BCD data
if(!decode(alphaRaw,t1Var.allBitCnt,dataDecoded+t2Var.dataCnt,&t1Var.dataCnt,
ALPHA_BIT_PER_CHAR,parity6,ALPHA_START_SENTINEL,ALPHA_END_SENTINEL))
{
bitsRever(alphaRaw,t1Var.allBitCnt); //offset BCD data
if(!decode(alphaRaw,t1Var.allBitCnt,dataDecoded+t2Var.dataCnt,&t1Var.dataCnt,
ALPHA_BIT_PER_CHAR,parity6,ALPHA_START_SENTINEL,ALPHA_END_SENTINEL))
_DBG("ALPHA Error\n");
else t1=1;
}
else t1=1;
}

if(t1&&t2)
{
avrDataPtr->eventCode = AVR_EVENT_READ_MAGSTRIPE;
avrDataPtr->datasize = t1Var.dataCnt + t2Var.dataCnt;
avrDataPtr->dataptr = dataDecoded;
_DBG("Size %u\n",avrDataPtr->datasize);
}

if(t2)//ALPHA
{
_DBG("ALPHA code\n");
for(int i=0;i<t2Var.dataCnt;i++) _DBG("%c",dataDecoded[i]+0x30);
_DBG("\n");
}
if(t1)//BCD
{
_DBG("BCD code\n");
for(int i=0;i<t1Var.dataCnt;i++) _DBG("%c",dataDecoded[i+t2Var.dataCnt]+0x20);
_DBG("\n");
}
memset(&t2Var,0x0,sizeof(t2Var));
memset(bcdRaw,0x0,sizeof(bcdRaw));

memset(&t1Var,0x0,sizeof(t1Var));
memset(alphaRaw,0x0,sizeof(alphaRaw));
}


static BYTE getBit(BYTE *bytePtr, WORD bitIndx)
{
return (bytePtr[bitIndx/8] >> (7-(bitIndx%8))) & 1;
}

void setBit(BYTE *bytePtr, WORD bitIndx, BYTE bit)
{
if(bit)
sbi(bytePtr[bitIndx/8],(7-(bitIndx%8)));
else
cbi(bytePtr[bitIndx/8],(7-(bitIndx%8)));
}

static void bitsRever(BYTE *src, WORD cnt)
{
BYTE b=0;
for(WORD i=0;i<(cnt/2);i++){
b = getBit(src,i);
setBit(src,i,getBit(src,cnt-1-i));
setBit(src,cnt-1-i,;
}
}

static BYTE getByte(BYTE *bytePtr, WORD bitIndx, BYTE bitPerChar, BYTE *parityArr)
{
BYTE result=0;
for(int i=0;i<bitPerChar;i++)
result |= getBit(bytePtr,bitIndx+i) << i;

if(getBit(bytePtr,bitIndx+bitPerChar) != parityArr[result]) return BAD_CHAR;

return result;
}

BOOL decode(BYTE *raw_src, WORD bitCnt, BYTE *dest, WORD *bytesCnt, BYTE bitPerChar,
BYTE *parityArr, BYTE startSentinel, BYTE endSentinel)
{
WORD offset=0;
BYTE lrc=0;
BYTE b;
*bytesCnt = 0;


if(bitCnt<=0)return FALSE;

while(offset < bitCnt>>3 && !raw_src[offset++]);
--offset;
offset *= 8; //bits offset


while(offset<bitCnt)
if(getByte(raw_src,offset++,bitPerChar,parityArr)==startSentinel)
{
--offset;
_DBG("SS off=%d\n",offset);
break;
}

_DBG("\n");
while(offset<bitCnt)
{
b = getByte(raw_src,offset,bitPerChar,parityArr);
_DBG("b=%c\n ",b+0x20);
if(b== BAD_CHAR)
{
_DBG("BAD off=%d\n",offset);
return FALSE;
}
offset+=bitPerChar+1;
dest[(*bytesCnt)++] = b;

if(b==endSentinel) {
dest[(*bytesCnt)++] = getByte(raw_src,offset,bitPerChar,parityArr); //lrc
break;
}
}
//_DBG("dest[(*bytesCnt)-1]=%x\n",dest[(*bytesCnt)-1]);

for(int i=0; i<(*bytesCnt)-1; i++) lrc ^= dest[i];//calculate LRC

if(lrc != dest[(*bytesCnt)-1])
{
_DBG("LRC ERR=%x\n", lrc);
return FALSE;
}

//_DBG("\nBCD=%d\n",*bytesCnt);
//debugMEM(dest,*bytesCnt);
//_DBG("\nEND\n");
return TRUE;
}

ISR(INT0_vect,ISR_NOBLOCK)//track 2
{

WORD t = TCNT3;
// _DBG("tr2=%x\n",t);
TCNT3 = 0x0;
TCNT0 = 0x0;
// if(t)
f2f((WORD)t,&t2Var,bcdRaw,BCD_BUFFER_SIZE);
}


ISR(INT1_vect)//track 1
{

WORD t = TCNT1;
// _DBG("tr1=%x\n",t);
TCNT1 = 0x0;
TCNT0 = 0x0;
// if(t)
// f2f((WORD)t,&t1Var,alphaRaw,ALPHA_BUFFER_SIZE);
}

static inline void f2f(WORD tc, struct trackVar *tVar, BYTE *rawDest, WORD rawCnt)
//a^?a*i`y", o'e^a`c,a`o`a*e"u" i'a` n~o`?o'e^o`o'?a`, i`a`n~n~e`a^[110], 110
{

if(tVar->byteCntRaw > rawCnt) return;

++tVar->cnt;

if(tVar->cnt<=LEADING_ZEROS)
{
if(tVar->cnt==1) return;
tVar->tmp += tc;
return;
}

if(tVar->cnt == LEADING_ZEROS+1)
{
tVar->prev = (tVar->tmp+tc) / LEADING_ZEROS;
return;
}
else
{
if(tVar->bitCnt8 > 7){
tVar->bitCnt8 = 0;
tVar->byteCntRaw++;
}

if(tVar->last_data){
tVar->last_data=0;
return;
}
// if(tc > ( (tVar->prev>>1)+(tVar->prev>>2)+(tVar->prev>>6)+10))
// _DBG("tc=%x\n",tc);
if(tc > ((tVar->prev>>1)+ (tVar->prev>>2) + (tVar->prev>>5) ))// > 145
{
tVar->last_data = 0;
tVar->prev = tc;
tVar->allBitCnt++;
tVar->bitCnt8++;
//uart_sendByte(0x00);
//_DBG("0\n");
return;
}
else
{
tVar->last_data=1;
tVar->allBitCnt++;
rawDest[tVar->byteCntRaw] |= 1<<(7-tVar->bitCnt8);
tVar->bitCnt8++;
//uart_sendByte(0x01);
//_DBG("1\n");
return;
}
}
}