/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "led.h"
#include "button.h"
#include "lcd_1602.h"
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <string.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
//Declaration des leds et buttons
LED_TypeDef led_rouge; 				//rouge
LED_TypeDef led_verte; 				//verte
LED_TypeDef led_jaune; 				//jaune
LED_TypeDef led_system;				//vert sur la carte

BUTTON_TypeDef button_rouge;		//rouge
BUTTON_TypeDef button_vert;			//vert
BUTTON_TypeDef button_jaune;		//jaune
BUTTON_TypeDef button_deux_joueur;	//gris
BUTTON_TypeDef button_system;		//bleu sur la carte

// fonction pour allumer et eteindre les leds
void fonction_led(char* couleur, int position) {
	if (strcmp(couleur,"R")==0 && (position==0)){  //eteind rouge
		Led_turnOff(&led_rouge);
	} else if (strcmp(couleur,"R")==0 && (position==1)){  //allume rouge
		Led_turnOn(&led_rouge);
	} else if (strcmp(couleur,"V")==0 && (position==0)){
		Led_turnOff(&led_verte);
	} else if (strcmp(couleur,"V")==0  && (position==1)){
		Led_turnOn(&led_verte);
	} else if (strcmp(couleur,"J")==0 && (position==0)){
		Led_turnOff(&led_jaune);
	} else if (strcmp(couleur,"J")==0  && (position==1)){
		Led_turnOn(&led_jaune);
	} else if (strcmp(couleur,"S")==0 && (position==0)){
		Led_turnOff(&led_system);
	} else if (strcmp(couleur,"S")==0  && (position==1)){
		Led_turnOn(&led_system);
	}
}

void affiche_lcd(char* contenu, int positiony, int clear) {
	if (clear==1){
		lcd_clr();
	}
	lcd_gotoxy(0,positiony);
	lcd_puts(contenu);
}

char* choix_aleatoire(void) {
	char* couleur_leds[3]={"R","V","J"}; //nos couleurs de led
	srand(time(0));
	int aleatoire = (rand() % (2 - 0 + 1)) + 0; //choix entre 0 et 2 pour avoir 3 valeurs differentes (3 couleurs/leds)
	char* choix = couleur_leds[aleatoire];
	return choix;
}

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */

//
  //configuration de l'horloge du système en 16MHz
  RCC->CR|=1; //activer HSI
  RCC->CFGR&=~(0b11);
  RCC->CFGR|=01; //selection de HSI
  HAL_InitTick(16000000);
//

// Init de nos leds et buttons
  Led_init(&led_system, GPIOA,5);				//led_system sur PA5
  Led_init(&led_rouge, GPIOA,6);				//led_rouge sur PA6
  Led_init(&led_verte, GPIOA,7);				//led_verte sur PA7
  Led_init(&led_jaune, GPIOC,4);				//led_jaune sur PC4

  Button_init(&button_system, GPIOC, 13);		//button_system sur PC13
  Button_init(&button_rouge, GPIOC, 0);			//button_rouge sur PC0
  Button_init(&button_vert, GPIOC, 1);			//button_vert sur PC1
  Button_init(&button_jaune, GPIOH, 2);			//button_jaune sur PC2
  Button_init(&button_deux_joueur, GPIOH, 3);	//button_deux_joueur sur PH3
//

/* EXEMPLE D'UTILISATION POUR LED ET BUTTON
  uint8_t last_button_state = 1; //button non appuyé
  uint8_t current_button_state = 1; //button non appuyé

  for (;;) {
	  //lire l’état courant
	  current_button_state = Button_State(&button_system);
	  //si front descendant (bouton appuyé)
	  if (last_button_state == 1 && (current_button_state == 0)) {
		  Led_turnOn(&led_system); //allume
		  //suppression des rebonds
		  HAL_Delay(20);
	  }
	  //si front montant (bouton relâché)
	  if (last_button_state == 0 && (current_button_state != 0)) {
		  //suppression des rebonds
		  HAL_Delay(20);
		  Led_turnOff(&led_system); //eteind
	  }
	  //mise à jour de l’état précédent du bouton
	  last_button_state = current_button_state;
  }
*/
  affiche_lcd("SIMON_STM32",0,1);

  int score = 0; //pour le systeme de score
  int deuxieme_joueur_joue = 0; //pour check si le 2e joueur a joué
  int score_un=0; //pour store le score du j1
  int score_deux=0; //pour store le score du j1
  char* suite_de_leds[100]={}; //la suite de leds a faire cligoter

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
	  lcd_init();


//gestion du mode 2joueurs
	  uint8_t last_button_2j_state = 1;
	  uint8_t current_button_2j_state = 1;
	  int etat_bouton_deux_joueurs=0;

	  //lire l’état courant
	  current_button_2j_state = Button_State(&button_deux_joueur);
	  //si front descendant (bouton appuyé)
	  if (last_button_2j_state  == 1 && (current_button_2j_state == 0) && (etat_bouton_deux_joueurs==0)) {
		  etat_bouton_deux_joueurs = 1; //si on avait pas activé le mode 2j, on l'active
		  fonction_led("S",1); //allume la led de la carte
	  } else if (last_button_2j_state  == 1 && (current_button_2j_state == 0) && (etat_bouton_deux_joueurs==1)) {
		  etat_bouton_deux_joueurs = 0; //si on avait activé le mode 2j, on le desactive
		  fonction_led("S",0); //eteind la led de la carte
	  }
	  //mise à jour de l’état précédent du bouton
	  last_button_2j_state = current_button_2j_state;


//gestion du bouton start/system
 	  uint8_t last_button_system_state = 1; //button non appuyé
 	  uint8_t current_button_system_state = 1; //button non appuyé
 	  int etat_bouton_start=0;

 	  //lire l’état courant
 	  current_button_system_state = Button_State(&button_system);
 	  //si front descendant (bouton appuyé)
 	  if (last_button_system_state  == 1 && (current_button_system_state == 0)) {
 		  etat_bouton_start = 1;
 	  }
	  //mise à jour de l’état précédent du bouton
	  last_button_system_state = current_button_system_state;


	  int perdu = 0; //pour check si le j a perdu

	  if (etat_bouton_start){
//Sequence d'allumage
		affiche_lcd("LET'S GO !",0,1);
	  	fonction_led("R", 1);
	  	HAL_Delay(250);
	  	fonction_led("V", 1);
	  	HAL_Delay(250);
	  	fonction_led("J", 1);
	  	HAL_Delay(250);
	  	fonction_led("R", 0);
	  	HAL_Delay(250);
	  	fonction_led("V", 0);
	  	HAL_Delay(250);
	  	fonction_led("J", 0);
	  	HAL_Delay(250);

	  	if (etat_bouton_deux_joueurs && !deuxieme_joueur_joue){ //lancement du mode 2J
	  		affiche_lcd("MODE 2J",0,1);
	  		affiche_lcd("J1!",1,0);
	  	}
	  	else if (!etat_bouton_deux_joueurs && !deuxieme_joueur_joue) { //lancement du mode 1J
	  		affiche_lcd("MODE 1J",0,1);
	  	}

	  	while (perdu!= 1) { //ici on lance un niveau (suite de leds), tant qu'on a pas perdu

	  		suite_de_leds[score] = choix_aleatoire();
	  		score++;
	  		for (int i = 0; i<score; i++){ //allume et eteinds les leds une par une par rapport au niveau
	  			fonction_led(suite_de_leds[i], 1); //on
	  			HAL_Delay(500);
	  			fonction_led(suite_de_leds[i], 0); //off
	  			HAL_Delay(100);
	  		}

	  		affiche_lcd("A VOUS !",0,1);
	  		int iLed=0;
	  		do { //le joueur appuie sur les boutons
	  			int bouton_appuye = 0;
	  			char* bouton;
	  			while (bouton_appuye==0){ //on prend l'entree utilisateur
	  				uint8_t last_button_rouge_state = 1; //button non appuyé
	  				uint8_t current_button_rouge_state = 1; //button non appuyé
	  				uint8_t last_button_vert_state = 1; //button non appuyé
	  				uint8_t current_button_vert_state = 1; //button non appuyé
	  				uint8_t last_button_jaune_state = 1; //button non appuyé
	  				uint8_t current_button_jaune_state = 1; //button non appuyé

	  				//lire l’état courant
	  				current_button_rouge_state = Button_State(&button_rouge);
	  				current_button_vert_state = Button_State(&button_vert);
	  				current_button_jaune_state = Button_State(&button_jaune);
	  				//si front descendant (bouton appuyé)
	  				if (last_button_rouge_state  == 1 && (current_button_rouge_state == 0)) {
	  					bouton_appuye = 1;
	  					bouton="R";
	  					fonction_led(bouton,1);
	  					HAL_Delay(200);
	  					fonction_led(bouton,0);
	  				} else if (last_button_vert_state  == 1 && (current_button_vert_state == 0)) {
	  					bouton_appuye = 1;
	  					bouton="V";
	  					fonction_led(bouton,1);
	  					HAL_Delay(200);
	  					fonction_led(bouton,0);
	  				} else if (last_button_jaune_state  == 1 && (current_button_jaune_state == 0)) {
	  					bouton_appuye = 1;
	  					bouton="J";
	  					fonction_led(bouton,1);
	  					HAL_Delay(200);
	  					fonction_led(bouton,0);
	  				}

	  				//mise à jour de l’état précédent du bouton
	  				last_button_rouge_state = current_button_rouge_state;
	  				last_button_vert_state = current_button_vert_state;
	  				last_button_jaune_state = current_button_jaune_state;

				}

	  			if (*bouton!=*suite_de_leds[iLed]){ //le joueur se trompe
	  		 		affiche_lcd("GAME OVER !",0,1);
	  				affiche_lcd("SCORE :",0,1);

	  				char score_char[10];
	  				sprintf(score_char, "%d", score-1); //rendre un int en char

	  				affiche_lcd(score_char,1,0);
	  				perdu = 1;
	  				etat_bouton_start=0;
	  	 		} else {
	  				perdu = 0;
	  			}
	  		iLed++;
	  		} while (iLed<score && perdu!=1); //tant qu'on a des leds a faire allume et qu'on a pas perdu
	  	} //fin du while qui test si on a perdu

	  	if (etat_bouton_deux_joueurs && perdu==1 && !deuxieme_joueur_joue){ //si le premier joueur perd en mode 2J
	  			affiche_lcd("J2!",0,1);
	  			etat_bouton_deux_joueurs = 0;
	  			perdu = 0;
	  			etat_bouton_start=1;
	  			score_un = score;
	  			deuxieme_joueur_joue = 1;
	  	} else if (deuxieme_joueur_joue){ //si tout le monde a joue en mode 2 joueurs, on fait la comparaison des scores
	  		score_deux = score;
	  		if (score_un>score_deux){affiche_lcd("JOUEUR 1 GAGNE!",0,1);}
	  		else if (score_un<score_deux){affiche_lcd("JOUEUR 2 GAGNE!",0,1);}
	  		else {affiche_lcd("EGALITE...",0,1);}
	  	}
	  } //fin du if button_start
	  	score=0;

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

  /* USER CODE END 3 */
} //fin du main

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
  PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */

  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/