#include "hal.h"
#include<string.h>

#define row_port PORT_A
#define col_port PORT_B

void dot_matrix(volatile uint8_t row_num,volatile uint8_t col_num);
void dot_matrix_off();
void dot_matrix_row_data(uint8_t);
void dot_matrix_string(volatile uint8_t user_str);
uint8_t* fetch_char_data(uint8_t c);
void dot_matrix_string_rolling_rl(volatile uint8_t *str);
void dot_matrix_string_rolling_lr(volatile uint8_t *str);
void dot_matrix_on(volatile uint8_t row_data,volatile uint8_t col_data);

struct Matrixchar{
  uint8_t name;
  uint8_t data[8];
};

typedef enum{
  left,
  right,
  up,
  down,
} scroll_type;

const struct Matrixchar capital_letters[]={
  {' ',{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}},
  {'A',{0x00,0x7c,0x12,0x11,0x11,0x12,0x7c,0x00}},
  {'B',{0x00,0x7f,0x49,0x49,0x49,0x49,0x36,0x00}},
  {'C',{0x00,0x1c,0x22,0x41,0x41,0x41,0x22,0x00}},
  {'D',{0x00,0x7f,0x41,0x41,0x41,0x22,0x1c,0x00}},
  {'E',{0x00,0x7f,0x49,0x49,0x49,0x49,0x41,0x00}},
  {'S',{0x00,0x46,0x49,0x49,0x49,0x49,0x49,0x31}},
  {'W',{0x00,0x7f,0x20,0x10,0x10,0x20,0x7f,0x00}},
  {'1',{0x00,0x00,0x42,0x41,0x7f,0x40,0x40,0x00}},
  {'2',{0x00,0x79,0x49,0x49,0x49,0x49,0x49,0x4f}},
  };

const struct Matrixchar small_letters[]={
  {'e',{0x00,0x18,0x34,0x54,0x54,0x54,0x18,0x00}},
  {'l',{0x00,0x00,0x00,0x00,0x3e,0x40,0x00,0x00}},
  {'c',{0x00,0x38,0x44,0x44,0x44,0x44,0x20,0x00}},
  {'o',{0x00,0x38,0x44,0x44,0x44,0x44,0x38,0x00}},
  {'m',{0x00,0x04,0x78,0x04,0x78,0x04,0x78,0x00}},
  {'S',{0x00,0x46,0x49,0x49,0x49,0x49,0x49,0x31}},
  };
  const uint8_t Space_void[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
void setup() {
  // put your setup code here, to run once:
  init_port(row_port,output);
  init_port(col_port,output);
  //capital letters
  const uint8_t Cap_A[8]={0x00,0x38,0x44,0x44,0x44,0x44,0x20,0x00};
  const uint8_t Cap_A_1[8]={0x00,0x00,0x18,0x34,0x54,0x54,0x54,0x18};
  //numbers
  const uint8_t num_1[8]={0x00,0x00,0x42,0x41,0x7f,0x40,0x40,0x00};
  const uint8_t num_2[8]={0x00,0x79,0x49,0x49,0x49,0x49,0x49,0x4f};
  //small letters
  const uint8_t small_a[8]={0x00,0x00,0x31,0x49,0x49,0x49,0x36,0x40};
  const uint8_t small_q[8]={0x00,0x06,0x09,0x09,0x09,0x76,0x80,0x40};
  //symbols
  const uint8_t symbol_dollar[8]={0x00,0x46,0x49,0x49,0xff,0xff,0x49,0x31};
  const uint8_t symbol_hash[8]={0x00,0xa8,0xa8,0x78,0x2c,0x3a,0x2c,0x2a};
  const uint8_t symbol_alpha[8]={0x18,0x24,0x24,0x18,0x1c,0x22,0x41,0x00};
  const uint8_t symbol_ohm[8]={0x80,0xb8,0xc4,0x04,0x04,0xc4,0xb8,0x80};
  //space
  
  while(1)
  {
    
    dot_matrix_string_scroll("Welcome",up);
    dot_matrix_string_scroll("Welcome",down);
  }
}


void loop() {
  // put your main code here, to run repeatedly:

}
//needed to remove ghosting
void dot_matrix_on(volatile uint8_t row_data,volatile uint8_t col_data)
{
  dot_matrix_off();//clear display to remove ghosting
  port_drive_out(row_port,row_data);
  port_drive_out(col_port,~(col_data));
  for(volatile long i=0;i<1000;i++);
}

void dot_matrix_off()
{
  port_drive_out(col_port,0xff);
}

void dot_matrix_row_data(const uint8_t input_arr[8])
{
  for(volatile uint8_t col=0;col<8;col++)
  {
    dot_matrix_on(input_arr[col],(1<<col));
  }
}

void dot_matrix_rolling(volatile uint8_t input_arr[8])
{
  
  for(uint8_t offset=0;offset<8;offset++)
  for(uint8_t repeat=0;repeat<20;repeat++)
  for(uint8_t col=0;col<8;col++)
  {
    if(col-offset>=0)
    {
      dot_matrix_on(input_arr[(col-offset)],(1<<col));
    }
    else
    {
      dot_matrix_on(input_arr[8+(col-offset)],(1<<col));
    }
  }
  
}
void dot_matrix_scroll_rl(volatile uint8_t cur_char,volatile uint8_t next_char)
{
  volatile uint8_t row_data;
  volatile uint8_t* cur_data=fetch_char_data(cur_char);
  volatile uint8_t* next_data=fetch_char_data(next_char);  
  for(uint8_t offset=0;offset<8;offset++)
    for(uint8_t repeat=0;repeat<20;repeat++)
      for(uint8_t col=0;col<8;col++)
      {
        if(col+offset<8)
        {
          row_data=cur_data[col+offset];
        }
        else{
          row_data=next_data[(col+offset)-8];
        }
        dot_matrix_on((row_data),(1<<col));
      }
}


void dot_matrix_string_rolling_rl(volatile uint8_t *str)
{
  volatile uint8_t next;
  dot_matrix_scroll_rl(' ',str[0]);
  for(uint8_t i=0;str[i]!='\0';i++)
  {
    next=(str[i+1]!='\0')?str[i+1]:' ';
    
      dot_matrix_scroll_rl(str[i],next);
    
  }
}

void dot_matrix_scroll_lr(volatile uint8_t cur_char,volatile uint8_t next_char)
{
  volatile uint8_t row_data;
  volatile uint8_t* cur_data=fetch_char_data(cur_char);
  volatile uint8_t* next_data=fetch_char_data(next_char);  
  for(uint8_t offset=0;offset<8;offset++)
    for(uint8_t repeat=0;repeat<20;repeat++)
      for(uint8_t col=0;col<8;col++)
      {
        if(col-offset>=0)
        {
          row_data=cur_data[col-offset];
        }
        else{
          row_data=next_data[8+(col-offset)];
        }
        dot_matrix_on((row_data),(1<<col));
      }
}

void dot_matrix_string_rolling_lr(volatile uint8_t *str)
{
  volatile uint8_t next;
  volatile uint8_t len=strlen((uint8_t*)str);
  dot_matrix_scroll_lr(' ',str[len-1]);
  for(uint8_t i=len-1;i>=0;i--)
  {
    next=i>0?str[i-1]:' ';
    
    dot_matrix_scroll_lr(str[i],next);
    
  }
}

void dot_matrix_string_scroll(volatile uint8_t *str,scroll_type user_scroll)
{
  switch(user_scroll)
  {
    case left:
      dot_matrix_string_rolling_rl(str);
      break;
    case right:
      dot_matrix_string_rolling_lr(str);
      break;
    case up:
      dot_matrix_string_scroll_up(str);
      break;
    case down:
      dot_matrix_string_scroll_down(str);
      break;
  }
}

void dot_matrix_rolling_tb(volatile uint8_t input_arr[8])
{
  for(uint8_t offset=0;offset<8;offset++)
    for(uint8_t repeat=0;repeat<20;repeat++)
      for(uint8_t col=0;col<8;col++)
      {
        
        uint8_t row_data = (input_arr[col] >> offset) | (input_arr[col] << (8 - offset));
        //top to bottom
        //uint8_t row_data = (input_arr[col] << offset) | (input_arr[col] >> (8 - offset));
        dot_matrix_on(row_data, (1 << col));
      }
}
void dot_matrix_scroll_down(volatile uint8_t cur_char,volatile uint8_t next_char)
{
  volatile uint8_t row_data;
  volatile uint16_t combined_data;
  volatile uint8_t* cur_data=fetch_char_data(cur_char);
  volatile uint8_t* next_data=fetch_char_data(next_char);
  for(uint8_t offset=0;offset<8;offset++)
    for(uint8_t repeat=0;repeat<20;repeat++)
      for(uint8_t col=0;col<8;col++)
      {
        combined_data=(cur_data[col]<<8)|next_data[col];
        row_data=(combined_data<<offset)>>8;
        dot_matrix_on((row_data),(1<<col));
      }
}

void dot_matrix_scroll_up(volatile uint8_t cur_char,volatile uint8_t next_char)
{
  volatile uint8_t row_data;
  volatile uint16_t combined_data;
  volatile uint8_t* cur_data=fetch_char_data(cur_char);
  volatile uint8_t* next_data=fetch_char_data(next_char);
  for(uint8_t offset=0;offset<8;offset++)
    for(uint8_t repeat=0;repeat<20;repeat++)
      for(uint8_t col=0;col<8;col++)
      {
        combined_data=(next_data[col]<<8)|cur_data[col];
        row_data=(combined_data>>offset)&0xff;
        dot_matrix_on((row_data),(1<<col));
      }
}

void dot_matrix_string_scroll_down(volatile uint8_t *str)
{
  for(uint8_t i=0;str[i]!='\0';i++)
  {
    if(str[i+1]!='\0')
    {
      dot_matrix_scroll_down(str[i],str[i+1]);
    }
    else
    {
      dot_matrix_scroll_down(str[i],' ');
    }
  }
}
void dot_matrix_string_scroll_up(volatile uint8_t *str)
{
  for(uint8_t i=0;str[i]!='\0';i++)
  {
    if(str[i+1]!='\0')
    {
      dot_matrix_scroll_up(str[i],str[i+1]);
    }
    else
    {
      dot_matrix_scroll_up(str[i],' ');
    }
  }
}
uint8_t* fetch_char_data(uint8_t c)
{
  for(uint8_t i=0;i<8;i++)
  {
    if(capital_letters[i].name==c)
      return capital_letters[i].data;
    if(small_letters[i].name==c)
      return small_letters[i].data;
  }
}