/********************************* (C) РОТЕК ***********************************
 * @module  bt_6701_commands
 * @file    bt_6701_commands.c
 * @version 1.0.0
 * @date    XX.XX.XXXX
 * $brief   bt_6701_commands
 *******************************************************************************
 * @history     Version  Author         Comment
 * XX.XX.XXXX   1.0.0    Telenkov D.A.  First release.
 *******************************************************************************
 */
#include "common_config.h"
#include "stm32f4xx.h"  
#include "bt_6701_commands.h"
#include "commands_api.h"
#include "gpio.h"
#include "buttons.h"
#include "led.h"
#include "netconf.h"
#include "stm32f4x7_eth_bsp.h"
#include "http_server.h"
#include "rtc.h"
#include "sntp_api.h"
#include "d_inouts.h"
#include "config_service.h"
#include "usart.h"
#include "spi_flash.h"

#include "FreeRTOS.h"
#include "task.h"

#include "lwip/opt.h"
#include "lwip/api.h"
#include "lwip/sys.h"

#ifdef PRINTF_STDLIB
#include <stdio.h>
#endif
#ifdef PRINTF_CUSTOM
#include "tinystdio.h"
#endif

#include <string.h>

bool ntpResult = false;
uint32_t SNTP_Time;

extern uint8_t DefCounter;
extern BUTTON_NO_FIX_t defButton;

extern uint8_t SetCounter;
extern BUTTON_NO_FIX_t setButton;

/**
  * @brief  Флаг ининциализации Eth интерфейса
  */
extern unsigned char eth_ready_flag;


static bool test_pair_pins(pair_pin_t *pins);
static void set_pin_as_output(GPIO_TypeDef *port, uint8_t pin);
static void set_pin_as_input(GPIO_TypeDef *port, uint8_t pin);
static void test_pin_print_result(pair_pin_t *pins, uint8_t *res);

// -------------------------------------------------------------------------- //
//                              __weak функции

/**
  * @brief  
  */
void TestProcessing(void)
{
  
    vTaskDelay(200);
}

/**
  * @brief  
  */
void Test_U232(void)
{
    // Отправляем символы в RS232
    for (uint16_t i = 0; i < 1023; i++)
    	ups_putchar('A');
  
    vTaskDelay(10);
    
  
    for (uint16_t i = 0; i < 1023; i++)
    {
        if (ups_getchar(500) != 'A') {
            printf("U232 FAIL\r\n");
            TEST_SetTest(TEST_WAIT);
            return;
        }
    }  
    
    printf("U232 OK\r\n");
    TEST_SetTest(TEST_WAIT);
}

#ifdef DALLAS_SENSOR_ENABLE
void COM_TestOW(void)
{
    uint8_t inputState;
    uint8_t start_state = 0;
    uint8_t end_state = 1;

    gpio_hw_config_pin(gpio_pins[WDATA1].port, gpio_pins[WDATA1].pin, GPIO_MODE_IN_CFG | 
				GPIO_SPEED_HIGH_CFG);
    gpio_hw_config_pin(gpio_pins[WDATA2].port, gpio_pins[WDATA2].pin, GPIO_MODE_IN_CFG | 
				GPIO_SPEED_HIGH_CFG);

    for (uint8_t i = 0; i < INPUTS_TOTAL_COUNT; i ++) {
      vTaskDelay(100);
    
      gpio_set((DOUT1 + i), start_state);

      vTaskDelay(100);
          
      if (get_state_din_outs((WDATA1 + i)) != start_state) {
          printf("OW FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
      }  

      gpio_set((DOUT1 + i), end_state);

      vTaskDelay(100);
      
      if (get_state_din_outs((WDATA1 + i)) != end_state) {
          printf("OW FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
      }  
    }

    vTaskDelay(100);

    printf("OW OK\r\n");
    TEST_SetTest(TEST_WAIT);
}
#endif

#ifdef DINS_ENABLE || DOUTS_ENABLE
/**
  * @brief  
  */
void Test_DRY(void)
{
    uint8_t inputState;
    uint8_t start_state = 0;
    uint8_t end_state = 1;
#ifdef DOUTS_ENABLE
#if defined RELAY_NC 
    start_state = 0;
    end_state = 1;
    for (uint8_t i = 0; i < OUTPUTS_TOTAL_COUNT; i ++) {
      set_state_douts((DOUT1 + i), 1);
    }
#endif

#ifdef RELAY_NO
    start_state = 1;
    end_state = 0;
#endif
    
    for (uint8_t i = 0; i < OUTPUTS_TOTAL_COUNT; i ++) {
#ifdef HARDWARE_BT6703
        if(i == 2) { // функционал определяющий аппаратную часть контроллера BT-6703 (выпущено 120 шт. переделанных из BT-6702, различия в релейных выходах)
          break;
        }
#endif 
      vTaskDelay(100);
      inputState = get_state_din_outs(DIN1);
    
      set_state_douts((DOUT1 + i), start_state);

      vTaskDelay(100);
          
      if (get_state_din_outs(DIN1) == inputState) {
#ifdef HARDWARE_BT6703
          if(i == 0) {
            set_state_douts((DOUT1 + 2), start_state);

            vTaskDelay(100);
                
            if (get_state_din_outs(DIN1) == inputState) {
                printf("DRY FAIL\r\n");
                TEST_SetTest(TEST_WAIT);
                return;
            }
          } else
#endif
        {
          printf("DRY FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
        }
      }  

      set_state_douts((DOUT1 + i), end_state);

      vTaskDelay(100);
      
      if (get_state_din_outs(DIN1) != inputState) {
#ifdef HARDWARE_BT6703
          if(i == 0) {
            set_state_douts((DOUT1 + 2), end_state);

            vTaskDelay(100);
                
            if (get_state_din_outs(DIN1) == inputState) {
                printf("DRY FAIL\r\n");
                TEST_SetTest(TEST_WAIT);
                return;
            }
          } else
#endif
        {
          printf("DRY FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
        }
      }  
    }
#else
    for (uint8_t i = 0; i < INPUTS_TOTAL_COUNT; i ++) {
      vTaskDelay(100);
    
      gpio_set((DOUT1 + i), start_state);

      vTaskDelay(100);
          
      if (get_state_din_outs((DIN1 + i)) != start_state) {
          printf("DRY FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
      }  

      gpio_set((DOUT1 + i), end_state);

      vTaskDelay(100);
      
      if (get_state_din_outs((DIN1 + i)) != end_state) {
          printf("DRY FAIL\r\n");
          TEST_SetTest(TEST_WAIT);
          return;
      }  
    }
#endif

	  vTaskDelay(100);

    printf("DRY OK\r\n");
    TEST_SetTest(TEST_WAIT);
}
#endif
/**
  * @brief  
  */
void vTest_DEF(void *params)
{
    static uint32_t timeout = 0;
    
    for (;;)
    {
        if (timeout++ > BUTTON_TIMEOUT) {
            timeout = 0;
            DefCounter = 0;
#ifdef LED_INIT_ERR
            LED_Off(LED_INIT_ERR);
#endif
#ifdef LED_ALARM
			LED_Off(LED_ALARM);
#endif
#ifdef LED_RED_MINOR
			LED_Off(LED_RED_MINOR);
#endif
            printf("DEF FAIL\r\n");
            TEST_SetTest(TEST_WAIT);
            ifTest_DEF = false;
            vTaskDelete(NULL);
        }  
	
        BUTTON_NoFixHandler(&defButton);
	
        if (DefCounter == 3)
        {
            timeout = 0;
            DefCounter = 0;
            printf("DEF OK\r\n");
	  
            /* Завершение теста T0 */
            /* Устанавливаем статус T0READY, сохраняем статус во флеш */
            COM_SetTestState(T0READY);
	  	    
            TEST_SetTest(TEST_WAIT);
            ifTest_DEF = false;
            vTaskDelete(NULL);
        }

        vTaskDelay(10);  
    }
    
}

/**
  * @brief
  */
void vTest_SET(void *params)
{
    static uint32_t timeout_set = 0;

    for (;;)
    {
        if (timeout_set++ > BUTTON_TIMEOUT) {
            timeout_set = 0;
            SetCounter = 0;
#ifdef LED_INIT_OK
            LED_Off(LED_INIT_OK);
#endif
#ifdef LED_GREEN_MINOR
			LED_Off(LED_GREEN_MINOR);
#endif
            printf("SET FAIL\r\n");
            TEST_SetTest(TEST_WAIT);
            ifTest_SET = false;
            vTaskDelete(NULL);
        }

        BUTTON_NoFixHandler(&setButton);

        if (SetCounter == 3)
        {
            timeout_set = 0;
            SetCounter = 0;
            printf("SET OK\r\n");

            /* Завершение теста T0 */
            /* Устанавливаем статус T0READY, сохраняем статус во флеш */
            COM_SetTestState(T0READY);

            TEST_SetTest(TEST_WAIT);
            ifTest_SET = false;
            vTaskDelete(NULL);
        }

        vTaskDelay(10);
    }

}

/**
  * @brief  Тестирование RTC
  */
void COM_TestRtc(void)
{
  /* Пытаемся синхронизироваться с NTP сервером */
  SNTP_Enable(true);
  SNTP_Poll();
  vTaskDelay(1000);

  /* Синхронизация удалась */
  if (ntpResult) {
    printf("RTC OK\r\n");
  }
  else
    printf("RTC FAIL SYNC\r\n");

  TEST_SetTest(TEST_WAIT);
}

/**
  * @brief  Тестирование SPIFLASH
  */
void COM_TestSPIflash(void)
{

  if (spi_flash_test()) {
    printf("SPIFLASH OK\r\n");
  }
  else
    printf("SPIFLASH FAIL SYNC\r\n");

  TEST_SetTest(TEST_WAIT);
}


/**
  * @brief  
  */
void Test_Ethernet(void)
{
    static bool ethernetInit = false;
    int timeout = 100; /* 10 sec timeout */
  
   // if (ethernetInit == false)
    {
        if (eth_ready_flag == 0) {
        	if(!ethernetInit){
        		ethernetInit = true;
				ETH_BSP_Config();
				 LwIP_Init();
        	}
        	else{
        		init_get_ip_address_controller();
        	}
        }
        /* Waiting ETH init */
        while ((eth_ready_flag == 0) && (timeout-- > 0)) {
            vTaskDelay(100);
        }

        if (eth_ready_flag == 0) {
            printf("ETH FAIL\r\n");
        }
        else {
            sys_thread_new("HTTP", vTaskTcpServer, NULL, 4*configMINIMAL_STACK_SIZE, tskIDLE_PRIORITY);
            ethernetInit = true;
        }
    }
  /*  else {
        printf("ETH OK\r\n");
    }*/
   
	TEST_SetTest(TEST_WAIT);
}

/**
  * @brief  
  */
void Test_Serno(void)
{
	macWaiting = true;
	macIsInstalled = false;
	
    // Устанавливаем статус тестирования "T1OK"
    COM_SetTestState(T0OK); 
    
    // Отправляем udp пакет с информацией
    //COM_TestSerno();  
	  
	// Пауза. В это время должен прийти GET запрос с MAC адресом. 
	//vTaskDelay(8000);
	//macWaiting = false;
	  
	//if (!macIsInstalled)
	//	printf("SERNO FAIL\r\n");
  
    for (uint8_t i = 0; i < 4; i++)
    {
        // Отправляем udp пакет с информацией
        COM_TestSerno();  
        // Пауза. В это время должен прийти GET запрос с MAC адресом. 
        vTaskDelay(8000);
        
        if (macIsInstalled)
            break;
    } 
    
    if (!macIsInstalled)
		printf("SERNO FAIL\r\n");
    
    TEST_SetTest(TEST_WAIT);
}




#define PAIR_PINS_SIZE      14

pair_pin_t pins_with_pair[PAIR_PINS_SIZE] = {
  {GPIOE, GPIO_Pin_6, 5, GPIOE, GPIO_Pin_5, 4},       /* 1 */ // 5, 4
  {GPIOE, GPIO_Pin_15, 46, GPIOB, GPIO_Pin_10, 47},   /* 2 */ // 46, 47
  {GPIOB, GPIO_Pin_3, 89, GPIOB, GPIO_Pin_4, 90},     /* 3 */ // 89, 90
  {GPIOB, GPIO_Pin_4, 90, GPIOB, GPIO_Pin_5, 91},     /* 4 */ // 90, 91
  {GPIOB, GPIO_Pin_5, 91, GPIOB, GPIO_Pin_6, 92},     /* 5 */ // 91, 92
  {GPIOC, GPIO_Pin_0, 15, GPIOC, GPIO_Pin_1, 16},     /* 6 */ // 15, 16
  {GPIOC, GPIO_Pin_1, 16, GPIOC, GPIO_Pin_2, 17},     /* 7 */ // 16, 17
  {GPIOA, GPIO_Pin_1, 24, GPIOA, GPIO_Pin_0, 23},     /* 8 */ // 23, 24
  {GPIOA, GPIO_Pin_1, 24, GPIOA, GPIO_Pin_2, 25},     /* 9 */ // 24, 25
  {GPIOA, GPIO_Pin_5, 30, GPIOA, GPIO_Pin_6, 31},     /* 10 */ // 30, 31
  {GPIOA, GPIO_Pin_6, 31, GPIOA, GPIO_Pin_7, 32},     /* 11 */ // 31, 32
  {GPIOC, GPIO_Pin_5, 34, GPIOB, GPIO_Pin_0, 35},     /* 12 */ // 34, 35
  {GPIOE, GPIO_Pin_12, 43, GPIOE, GPIO_Pin_13, 44},   /* 13 */ // 43, 44
  {GPIOB, GPIO_Pin_12, 51, GPIOB, GPIO_Pin_13, 52},   /* 14 */ // 51, 52
};

uint8_t pair_pin_resut[PAIR_PINS_SIZE];

// ------------------------------------------------------------------------ //

//
void Test_Pins(void)
{
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
 
  if (test_pair_pins(pins_with_pair))
    printf("PIN OK\r\n");
  else
    printf("PIN FAIL\r\n");

  TEST_SetTest(TEST_WAIT);
}

//
static bool test_pair_pins(pair_pin_t *pins)
{
  uint8_t res_1 = Bit_RESET;
  uint8_t res_2 = Bit_RESET;
  bool ret = true;

  // Low level PE_13 - ERST ethernet PHY
  set_pin_as_output(GPIOE, GPIO_Pin_13);
  GPIO_ResetBits(GPIOE, GPIO_Pin_13);

  for (int i = 0; i < PAIR_PINS_SIZE; i++)
  {
    set_pin_as_output(pins[i].first_port, pins[i].first_pin);
    set_pin_as_input(pins[i].second_port, pins[i].second_pin);

    GPIO_SetBits(pins[i].first_port, pins[i].first_pin);
    vTaskDelay(10);

    res_1 = GPIO_ReadInputDataBit(pins[i].second_port, pins[i].second_pin);

    GPIO_ResetBits(pins[i].first_port, pins[i].first_pin);
    vTaskDelay(10);

    res_2 = GPIO_ReadInputDataBit(pins[i].second_port, pins[i].second_pin);

    if (res_1 != res_2) {
      pair_pin_resut[i] = 1;
      ret = false;
    }
    else 
      pair_pin_resut[i] = 0;

    set_pin_as_input(pins[i].first_port, pins[i].first_pin);
  }

  test_pin_print_result(pins, pair_pin_resut);

  return ret;
}

//
static void set_pin_as_output(GPIO_TypeDef *port, uint8_t pin)
{
  GPIO_InitTypeDef GPIO_InitStructure = {0};

  GPIO_InitStructure.GPIO_Pin = pin;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(port, &GPIO_InitStructure);
}

//
static void set_pin_as_input(GPIO_TypeDef *port, uint8_t pin)
{
  GPIO_InitTypeDef GPIO_InitStructure = {0};

  GPIO_InitStructure.GPIO_Pin = pin;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_Init(port, &GPIO_InitStructure);
}

//
static void test_pin_print_result(pair_pin_t *pins, uint8_t *res)
{
  for (int i = 0; i < PAIR_PINS_SIZE; i++) {
    if (res[i] != 0) {
      printf("Short circuit between pins:\r\n");
      printf("\t%u %u\r\n", pins[i].first_pin_num, pins[i].second_pin_num);
    }
  }
  printf("\r\n"); 
}

/********************************* (C) РОТЕК **********************************/