// STM32 Nucleo-L031K6 HAL Blink + printf() example
// Simulation: https://wokwi.com/projects/367244067477216257

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stm32l0xx_hal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BUFFSIZE	6
#define SUCCESS		0
#define	FAIL		1
#define	REPEAT		2

// ST Nucleo Green user LED (PB3)
#define LD3_GPIO_Port               GPIOB
#define LD3_Pin                 GPIO_PIN_3
#define LED_PORT_CLK_ENABLE     __HAL_RCC_GPIOB_CLK_ENABLE
#define VCP_TX_Pin GPIO_PIN_2
#define VCP_RX_Pin GPIO_PIN_15


TIM_HandleTypeDef htim2;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM2_Init(void);

typedef int (*ptrFunc)(void); 

typedef struct{
	char *nomeProcesso;
    int memoriaAloc;
    float tempoExec;
    ptrFunc procFunc;
} Process;

Process circularBuffer[BUFFSIZE];
int head=0, tail=0;
char *errorMessage;

//prototypes
void resetBuffer(Process buffer[], int *head, int *tail);
char addProc(char *newNomeProcesso, int newMemAloc, float newTempoExec, ptrFunc newProcFunction);
char removeProc(void);
void runBufferProcList(Process *buffer);
int BufferIsFull(void);
int BufferIsEmpty(void);

//Tasks
int manageConnections(void);
int scanNetworkPorts(void);
int checkNetworkStatus(void);
int updateFirewallRules(void);
int checkSystemLoad(void);
int auditVPNLogs(void);

int main(void)
{
  int dummyRt = 0;
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_TIM2_Init();

  dummyRt = addProc("ManageSSHConnections", 400, 100, manageConnections);
  dummyRt = addProc("ScanNetworkPorts", 800, 200, scanNetworkPorts);
  dummyRt = addProc("CheckNetworkStatus", 100, 50, checkNetworkStatus);
  dummyRt = addProc("UpdateFirewallRules", 1400, 1100, updateFirewallRules);
  dummyRt = addProc("CheckSystemLoad", 80, 90, checkSystemLoad);

  while (1)
  {
    runBufferProcList(circularBuffer);

    if(addProc("AuditVPNLogs", 200, 450, auditVPNLogs) != 0){
      printf(errorMessage);
      removeProc();
      dummyRt = addProc("AuditVPNLogs", 200, 450, auditVPNLogs);
    }	

    removeProc();
    dummyRt = addProc("AuditVPNLogs_2", 350, 450, auditVPNLogs);

    runBufferProcList(circularBuffer);
  }
}

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLLMUL_4;
  RCC_OscInitStruct.PLL.PLLDIV = RCC_PLLDIV_2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  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_1) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_TIM2_Init(void)
{

  TIM_MasterConfigTypeDef sMasterConfig = {0};

  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 32000-1;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 1000-1;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_OnePulse_Init(&htim2, TIM_OPMODE_SINGLE) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  HAL_GPIO_WritePin(LD3_GPIO_Port, LD3_Pin, GPIO_PIN_RESET);

  GPIO_InitStruct.Pin = VCP_TX_Pin|VCP_RX_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF4_USART2;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LD3_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD3_GPIO_Port, &GPIO_InitStruct);

}

void Error_Handler(void)
{
  __disable_irq();
  while (1)
  {
  }
}

#ifdef  USE_FULL_ASSERT

void assert_failed(uint8_t *file, uint32_t line)
{

}
#endif 

void resetBuffer(Process buffer[], int *head, int *tail) {
	int i = 0;
	
	for(i = 0; i < BUFFSIZE; i++){
		buffer[i].nomeProcesso = NULL;
		buffer[i].memoriaAloc = 0;
		buffer[i].tempoExec = 0;
		buffer[i].procFunc = NULL;
	}

    *head = 0;
    *tail = 0;
}

char addProc(char *newNomeProcesso, int newMemAloc, float newTempoExec, ptrFunc newProcFunction){
	if(BufferIsFull()){
		errorMessage = "\n> The buffer is full! It's not possible to add new elements to the buffer.\n";
		return FAIL;
	} else {			 		
		circularBuffer[tail].nomeProcesso = newNomeProcesso;
		circularBuffer[tail].memoriaAloc = newMemAloc;
		circularBuffer[tail].tempoExec = newTempoExec;
		
		printf("\n\t> Adding a new process.\n\t> Process running: \"" );
		newProcFunction();
		printf("\"\n");
		
		circularBuffer[tail].procFunc = newProcFunction;
		
		//	updates the end of the circular buffer	
		tail = (tail + 1) % BUFFSIZE;
	}
	return SUCCESS;
}

char removeProc(void){
	if(BufferIsEmpty()){
		errorMessage = "\n> The buffer is empty. There are no processes to remove.\n";
		return FAIL;
	} else {
		//	updates the front of the circular buffer
		printf("\n\t> Removed process: %s", circularBuffer[0].nomeProcesso);
		printf("\n\t> Running: ");
		circularBuffer[0].procFunc();
		printf("\n");	
		head = (head + 1) % BUFFSIZE;
	}
	
	return SUCCESS;
}

void runBufferProcList(Process *buffer)
{
	float lastTimeExec[BUFFSIZE];
	int i;
	
	i = 0;
	printf("\n\n\t\t\t< Buffer running >");
	
//	while(true){
		for(i=0; i<BUFFSIZE-1; i++){
			printf("\n");
			
			if(buffer[i].procFunc()==REPEAT){
				printf("\n\t--> The process \"%s\" is scheduled to run again shortly.\n", buffer[i].nomeProcesso);
			}
			else{
				printf("\n\t--> Process executed successfully!");
			}
		}
//	}

	printf("\t\t    < Buffer execution terminated. >\n\n\n");
}

int BufferIsFull()
{
	return(((tail+1)%BUFFSIZE)==head);
}

int BufferIsEmpty()
{
	return(head == tail);
}

int manageConnections(void){
	printf(")-> Managing Network Connections...");
  
  HAL_Delay(1000);
  HAL_GPIO_TogglePin(LD3_GPIO_Port, LD3_Pin);
  resetBuffer(circularBuffer, &head, &tail);

	return(SUCCESS);
}

int scanNetworkPorts(void){
	printf(")-> Scanning Network Ports...");

  HAL_Delay(500);
	return(REPEAT);
}

int checkNetworkStatus(void) {	
    printf(")-> Checking Network Status...");

    HAL_Delay(500);
    return(SUCCESS);
}

int updateFirewallRules(void) {
    printf(")-> Updating Firewall Rules...");
    
    HAL_Delay(500);
    return(SUCCESS);
}

int checkSystemLoad(void) {
    printf(")-> Checking System Load...");
    
    HAL_Delay(500);
    return(REPEAT);
}

int auditVPNLogs(void){
	printf(")-> Start reading audit VPN logs...");
	
  HAL_Delay(500);
  return(SUCCESS);
}