// Handles different menu selection
//
// leftRightIndex: index for determining menus
// upDownIndex, currDollars, currCents: needed for calling print_menu
void select_menu(int *leftRightIndex, int upDownIndex, int currDollars, int currCents) {
  if (*leftRightIndex == 0) {
      print_welcome();
  } else if (*leftRightIndex == 1) {
    print_menu(upDownIndex, currDollars, currCents);
  }
  else {
    clear_display();
    delay(1000); //1ms
    LED_toggle();
    display_string("Order Confirmed!");
    display_string("                        ");
    delay(1000000); //1sec
    display_string("Preparing Now...");
    delay(3000000); //3sec
    clear_display();
    delay(1000); //1ms
    display_string("Order Ready!");
    LED_toggle();
    delay(3000000); //3sec
    *leftRightIndex = 0;
    clear_display();
    delay(1000); //1ms
    print_welcome();
  }
}

int main(void){
	_delay_ms(1000);

/* Initialize OLED Display */
	init_OLED();
	reset_display();

	while(1){

		/*Draw image on Screen*/
		for(int i=0;i<128*8;i++)     // show 128* 64 Logo
					SendChar(pgm_read_byte(logo2+i));

		sendcommand(0x2f);  /*Scroll on*/
		_delay_ms(4000);
		sendcommand(0x2e);  /*Scroll off*/


		clear_display();

/* Draw text from font */
		sendStrXY("   VISIT US AT  ",0,0);
		sendStrXY("      WWW.      ",2,0);
		sendStrXY(" ELEMENTZONLINE ",4,0);
		sendStrXY("      .COM      ",6,0);

		_delay_ms(8000);
		clear_display();
	}
return 0;
}

static void text_loglevel_change()
{
	/* Only reset the display if we're switching between nice display
	 * and displaying debugging output */
	
	if (console_loglevel >= SUSPEND_ERROR) {
		if (lastloglevel < SUSPEND_ERROR)
			clear_display();

		show_cursor();

		if (lastloglevel > -1)
			printf("\nSwitched to console loglevel %d.\n", console_loglevel);

		if (lastloglevel > -1 && lastloglevel < SUSPEND_ERROR) {
			printf("\n** %s\n", lastheader);
		}
	
	} else if (lastloglevel >= SUSPEND_ERROR || lastloglevel == -1) {
		clear_display();
		hide_cursor();
	
		/* Get the nice display or last action [re]drawn */
		text_prepare_status(1, 0, SUSPEND_UI_MSG, NULL);
	}
	
	lastloglevel = console_loglevel;
}

void draw_thread(void *arg)
{
  struct vfd_ioctl_data *data;
  struct vfd_ioctl_data draw_data;
  unsigned char buf[17];
  int count = 0;
  int pos = 0;


  data = (struct vfd_ioctl_data *)arg;

  draw_data.length = data->length;
  memset(draw_data.data, 0, sizeof(draw_data.data));
  memcpy(draw_data.data,data->data,data->length);

  thread_stop = 0;

  count = utf8_len(&draw_data.data[0], draw_data.length);

  if(count > mode_digit)
  {
    while(pos < draw_data.length)
    {
       if(kthread_should_stop())
       {
    	   thread_stop = 1;
    	   return;
       }

       clear_display();
       memset(buf,0, sizeof(buf));
       int countb = utf8_count(&draw_data.data[pos], draw_data.length - pos, 8);
       memcpy(buf, &draw_data.data[pos], countb);
       YWPANEL_VFD_ShowString(buf);
       msleep(200);
       if (draw_data.data[pos] > 128)
       {
           pos += 2;
       } else {
           pos += 1;
       }
    }
  }

  if(count > 0)
  {
      clear_display();
      memset(buf,0, sizeof(buf));
      int countb = utf8_count(&draw_data.data[0], draw_data.length, 8);
      memcpy(buf, draw_data.data, countb);
      YWPANEL_VFD_ShowString(buf);
  }
  else VFD_clr();

  thread_stop = 1;
}

int multi_view_mode(char previous) {
    sensor_changer(&sensor_selector, &previous);
    lcd_display_top_row("Mult");
    lcd_display_bottom_row();
    //use sweep_num to see what stage of 'turning' the object is at

    char a = read_keypad(33);
    if (a == 'A'&& previous != a) {
        SYSTICK_IntCmd(DISABLE);
        clear_display(59);
        char a = read_keypad(33);
        previous = keypad_check(a, previous);
        return 0;
    }
    else if (a == 'B'&& previous != a) {
        SYSTICK_IntCmd(DISABLE);
        clear_display(59);
        char a = read_keypad(33);
        previous = keypad_check(a, previous);
        return 1;
    }
    else if (a == 'C'&& previous != a) {
        servoreset();
        SYSTICK_IntCmd(ENABLE);
        clear_display(59);
        char a = read_keypad(33);
        previous = keypad_check(a, previous);
        return 2;
    }
    else if (a == 'D'&& previous != a) {
        servoreset();
        SYSTICK_IntCmd(ENABLE);
        char a = read_keypad(33);
        previous = keypad_check(a, previous);
        return 3;
    }
    else {
        keypad_change_servo_speed(&turnspeed, a, &previous);
        keypad_change_servo_start_pos(&servo_start, a, &previous);
        keypad_change_servo_stop_pos(&servo_stop, a, &previous);
        keypad_change_sample_rate(&samplerate, a, &previous);
        keypad_activate_interrupt(a, &previous);
        average_calculator(us_dist_arr, ir_dist_arr, array_counter, &us_avg, &ir_avg);
        previous = keypad_check(a, previous);

        //distanceircalc();
        //RTC_AlarmIntConfig((LPC_RTC_TypeDef *) LPC_RTC, RTC_TIMETYPE_SECOND, ENABLE);
        //RTC_SetAlarmTime((LPC_RTC_TypeDef *) LPC_RTC, RTC_TIMETYPE_SECOND, 1);
        return 3;
    }
}

void display_init(uint8_t brightness)
{
	// outputs
	DATA_DDR  |= _BV(DATA_BIT);
	CLOCK_DDR |= _BV(CLOCK_BIT);
	LATCH_DDR |= _BV(LATCH_BIT);
	BLANK_DDR |= _BV(BLANK_BIT);

	// inputs
	SIGNATURE_DDR &= ~(_BV(SIGNATURE_BIT_0));
	SIGNATURE_DDR &= ~(_BV(SIGNATURE_BIT_1));
	SIGNATURE_DDR &= ~(_BV(SIGNATURE_BIT_2));
	
	// enable pullups for shield bits
	SIGNATURE_PORT |= _BV(SIGNATURE_BIT_0);
	SIGNATURE_PORT |= _BV(SIGNATURE_BIT_1);
	SIGNATURE_PORT |= _BV(SIGNATURE_BIT_2);

	LATCH_ENABLE;
	clear_display();

	detect_shield();

	// Inititalize timer for multiplexing
	TCCR0B |= (1<<CS01); // Set Prescaler to clk/8 : 1 click = 1us. CS21=1
	TIMSK0 |= (1<<TOIE0); // Enable Overflow Interrupt Enable
	TCNT0 = 0; // Initialize counter
	
	set_brightness(brightness);
}

void sonar() //initialize sonar pins and triggering sonar

{

overflow = 0;

PORTC|=(1<<PC0);

_delay_us(50);

PORTC&=~(1<<PC0);

while(!(PINC&(1<<PC1)));

TCNT2 = 0;

while ((PINC&(1<<PC1))&&TCNT2<245);

print_integer(overflow);

counter = overflow*256 + TCNT2;

time = counter*(1024/16);

clear_display();

print_integer(counter);

_delay_ms(200);

}

int main(void)
{
	
	initialize( 1, 1 );
	enable_display( 1, 0, 0 );
	clear_display();
	return_cursor();
	set_mode( 0, 1 );
	
	
	write_symbol(' ');
	write_symbol(' ');
	write_symbol(' ');
	write_symbol(' ');
	write_symbol(' ');
	
	write_symbol('4');
	write_symbol('a');
	write_symbol('4');
	write_symbol('i');
	write_symbol('k');
	

    while(1);
}

void i2c_oled::reset_display(void)
{
  displayOff();
  clear_display();

  displayOn();
}

static bool search_init(const char* file){
    rb->memset(search_string, 0, sizeof(search_string));

    if (!rb->kbd_input(search_string,sizeof search_string)){
        clear_display();
        rb->splash(0, "Searching...");
        fd = rb->open(file, O_RDONLY);
        if (fd < 0)
            return false;

        fdw = rb->creat(resultfile);

        if (fdw < 0) {
#ifdef HAVE_LCD_BITMAP
            rb->splash(HZ, "Failed to create result file!");
#else
            rb->splash(HZ, "File creation failed");
#endif
            rb->close(fd);
            return false;
        }

        file_size = rb->lseek(fd, 0, SEEK_END);

        return true;
    }

    return false ;
}

/** \brief Show help file
 *
 * Read 'help.txt' and display it via 'less'.
 * Local 'help.txt' in actual directory overrides default file
 * in PKG_DATA_DIR
 */
int show_help(void) {
    int rc;
    char filename[] = "help.txt";
    char *helpfile;
    char *cmdstr;

    if (g_access(filename, R_OK) == 0) {
	helpfile = g_strdup(filename);
    } else {
	helpfile = g_strconcat(PACKAGE_DATA_DIR, G_DIR_SEPARATOR_S,
		filename, NULL);
	if (g_access(helpfile, R_OK) != 0) {
	    g_free(helpfile);
	    return -1;
	}
    }

    cmdstr = g_strdup_printf("less %s", helpfile);

    endwin();
    rc=system("clear");
    rc=system(cmdstr);
    rc=system("clear");

    g_free(helpfile);
    g_free(cmdstr);

    set_term(mainscreen);
    clear_display();
    return 0;
}

void display_init() {
	// Setting up ports.
	SYSCTL_RCGC2_R |= SYSCTL_DC4_GPIOB; // Enable GPIOB	
        //maybe delay2 here
        delay2(10000);
        SYSCTL_RCGC2_R |= SYSCTL_DC4_GPIOD; // Enable GPIOD
        delay2(10000);
	GPIO_PORTB_DIR_R |= 0x7f;
	GPIO_PORTD_DIR_R |= 0xe0;

	GPIO_PORTB_AFSEL_R &= 0xffffff80;
	GPIO_PORTD_AFSEL_R &= 0xffffff1f;	

	GPIO_PORTB_DEN_R |= 0x7f; // Enable port B		
    	GPIO_PORTD_DEN_R |= 0xe0; // Enable port D
        
    	// Function set commands separated by delay2s, as per cycle
    	//delay2(100);
        //SysCtldelay2(5*SysCtlClockGet()/(3*1000)); //5msec
        delay2(5000); //5msec
	function_set(0, 0);
        //SysCtldelay2(5*SysCtlClockGet()/(3*1000)); //5msec
	//delay2(10);
        delay2(5000); //5msec
	function_set(0, 0);
        //SysCtldelay2(2*SysCtlClockGet()/(3*10000)); //200usec
        delay2(200); //200usec
	//delay2(10);
	function_set(0, 0);
        function_set(1, 0); //two lines
        display_off();
        clear_display();
        entry_mode_set(1,0);
}

void display_multiplex(void)
{
	clear_display();
	if (display_on) {
		switch (shield) {
#ifdef iv6_support
			case SHIELD_IV6:
				write_vfd_iv6(multiplex_counter, calculate_segments_7(data[multiplex_counter]));
				break;
#endif
#ifdef iv17_support
			case SHIELD_IV17:
				write_vfd_iv17(multiplex_counter, calculate_segments_16(data[multiplex_counter]));
				break;
#endif
			case SHIELD_IV18:
				if (multiplex_counter == 8) 
					write_vfd_iv18(8, g_iv18seg0);
				else 
					write_vfd_iv18(multiplex_counter, calculate_segments_7(data[7-multiplex_counter]));
				break;
#ifdef iv17_6digit_support
			case SHIELD_IV17_6D:
				write_vfd_iv17_6d(multiplex_counter, calculate_segments_16(data[multiplex_counter]));
				break;
#endif
			default:
				break;
		}
	}
	multiplex_counter++;
	if (multiplex_counter == mpx_limit) multiplex_counter = 0;
	STROBE_HIGH;  // Pulse Strobe to update Latch data
	STROBE_LOW;	
}

int main (void) {
    long i;

    init_timer(&data[6], &data[0]);
    init_power();
    play_system_sound(0x4003, 1);

    clear_display();

    for (i = -5; i <= 5; i++) {
	set_lcd_number(LCD_SIGNED, i % 5, LCD_DECIMAL_0);
	refresh_display();
	wait_release();
	wait_press();
    }

    for (i = -5; i <= 5; i++) {
	set_lcd_number(LCD_SIGNED, i % -5, LCD_DECIMAL_0);
	refresh_display();
	wait_release();
	wait_press();
    }

    shutdown_timer();

    return 0;
}

int main (void) {
    char playing;

    while (1) {
	init_timer(&data[6], &data[0]);
	init_power();

	set_lcd_segment(0x3020);
	refresh_display();

	play_system_sound(0x4003, 1);

	wait_release();
	wait_press();

	play_system_sound(0x4003, 0);

	do {
	    get_sound_playing_flag(0x700c, &playing);
	} while (playing);

	clear_display();
	refresh_display();

	shutdown_timer();
	shutdown_power();
    }
    return 0;
}

//Displays current alarm time
//Brightness level is an amount of time the LEDs will be in - 200us is pretty dim but visible.
//Amount of time during display is around : [ BRIGHT_LEVEL(us) * 5 + 10ms ] * 10
//Roughly 11ms * 10 = 110ms
//Time on is in (ms)
void display_alarm_time(uint16_t time_on)
{
    uint16_t bright_level = 50;
    
    //time_on /= 11; //Take the time_on and adjust it for the time it takes to run the display loop below

    for(uint16_t j = 0 ; j < time_on ; j++)
    {
        //Display normal hh:mm time
        if(hours_alarm > 9)
        {
            display_number(hours_alarm / 10, 1); //Post to digit 1
            delay_us(bright_level);
        }

        display_number(hours_alarm % 10, 2); //Post to digit 2
        delay_us(bright_level);

        display_number(minutes_alarm / 10, 3); //Post to digit 3
        delay_us(bright_level);

        display_number(minutes_alarm % 10, 4); //Post to digit 4
        delay_us(bright_level);

        
        //During debug, display mm:ss
        /*display_number(minutes_alarm / 10, 1); 
        delay_us(bright_level);

        display_number(minutes_alarm % 10, 2); 
        delay_us(bright_level);

        display_number(seconds_alarm / 10, 3); 
        delay_us(bright_level);

        display_number(seconds_alarm % 10, 4); 
        delay_us(bright_level);

        display_number(10, 5); //Display colon
        delay_us(bright_level);*/
        
        //Flash colon for each second
        if(flip == 1) 
        {
            display_number(10, 5); //Post to digit COL
            delay_us(bright_level);
        }
        
        //Check whether it is AM or PM and turn on dot
        if(ampm_alarm == AM)
        {   
            display_number(12, 6); //Turn on dot on apostrophe
            delay_us(bright_level);
        }

        clear_display();
        delay_ms(1);
    }
    
}

int setweight(int weight)
{				//  write weight to netkeyer

    extern int keyerport;

    int retval;
    char buff[4];

    if (keyerport == NET_KEYER && weight > -51 && weight < 51) {

	sprintf(buff, "%d", weight);

	retval = netkeyer(K_WEIGHT, buff);

	if (retval < 0) {
	    mvprintw(24, 0, "keyer not active ?");
	    sleep(1);
	    clear_display();
	}

    }

    return (0);

}

void delete_qso(void) {

    int x;
    struct stat statbuf;
    int lfile;
    char logline[100];
    char call[15], bandmode[6];

    mvprintw(13, 29, "OK to delete last qso (y/n)?");
    x = key_get();

    if ((x == 'y') || (x == 'Y')) {

	if ((lfile = open(logfile, O_RDWR)) < 0) {

	    TLF_LOG_WARN("I can not find the logfile...");
	} else {

	    fstat(lfile, &statbuf);

	    if (statbuf.st_size >= LOGLINELEN) {
		if (qtcdirection > 0) {
		    // read band, mode and call from last QSO line
		    lseek(lfile, ((int)statbuf.st_size - LOGLINELEN), SEEK_SET);
		    IGNORE(read(lfile, logline, LOGLINELEN - 1));;

		    g_strlcpy(bandmode, logline, 6);
		    g_strlcpy(call, logline + 29, 15);
		    g_strchomp(call);

		    // delete QTC's for that combination of band, mode and call
		    delete_last_qtcs(call, bandmode);
		}
		IGNORE(ftruncate(lfile, statbuf.st_size - LOGLINELEN));
	    }

	    fsync(lfile);
	    close(lfile);

	    if (qsos[nr_qsos][0] != ';') {
		band_score[bandinx]--;
		qsonum--;
		qsonr_to_str();
	    }

	    nr_qsos--;
	    qsos[nr_qsos][0] = '\0';
	}

	scroll_log();

    }

    attron(COLOR_PAIR(C_LOG) | A_STANDOUT);
    mvprintw(13, 29, "                            ");

    printcall();

    clear_display();
}

/*
Description: Forecast state + Calculation of forecast
State from Diagram: S07
*/
state do_DISP_FC()
{
	int averagePressure = 0;
	
	for (int i=0; i<5; i++)
	averagePressure += pressureData[i];
	
	averagePressure /= 5; //TODO: should all this be floats?ich		
	
	if (pressureData[3] > averagePressure && pressureData[4] > averagePressure)
	{
		GotoLCD_Location(1,1);
		Send_String("Forecast: Good");
		GotoLCD_Location(1,2);
		Send_String("Weather Expected");
		howistheweather = 1;
	}
	else
	{
		GotoLCD_Location(1,1);
		Send_String("Forecast: Bad");
		GotoLCD_Location(1,2);
		Send_String("Weather Expected");
		howistheweather = 0;
	}
	
	if (isforecast ==0)
	{
		clear_display();
		return DISP_TEMP;
	}
	else
	return DISP_FC;

}	

void setup_display(void) {
	pinMode(DATA, OUTPUT);
	pinMode(CLOCK, OUTPUT);
	pinMode(LATCH, OUTPUT);
	clear_display();
	swap_displays();
}