// #include "main.h"
#include "FreeRTOS.h"
#include "task.h"
#include <stdio.h>

// Deklarasi Handle UART untuk komunikasi serial
UART_HandleTypeDef huart2;

// Prototipe fungsi
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
void vGreenTask(void *pvParameters);
void vBlueTask(void *pvParameters);
void vRedTask(void *pvParameters);

// --- Sumber daya untuk RedTask (Alokasi Statik) ---
#define RED_TASK_STACK_SIZE 128
StackType_t uxRedTaskStack[RED_TASK_STACK_SIZE];
StaticTask_t xRedTaskTCB; // Task Control Block

/**
  * @brief  Fungsi main
  * @retval int
  */
int main(void)
{
  // Inisialisasi HAL
  HAL_Init();

  // Konfigurasi jam sistem
  SystemClock_Config();

  // Inisialisasi GPIO dan USART
  MX_GPIO_Init();
  MX_USART2_UART_Init();

  printf("Hands-On 1: Membuat Beberapa Task\n\n");

  // --- 1. Buat GreenTask (Prioritas Tinggi, Alokasi Dinamis) ---
  BaseType_t xTask1Status = xTaskCreate(
      vGreenTask,
      "GreenTask",
      128, // Ukuran stack
      NULL,
      tskIDLE_PRIORITY + 2, // Prioritas tinggi
      NULL
  );

  // Periksa keberhasilan pembuatan GreenTask
  if (xTask1Status == pdPASS) {
    printf("GreenTask berhasil dibuat.\n");
  } else {
    printf("ERROR: Gagal membuat GreenTask!\n");
  }

  // --- 2. Buat BlueTask (Prioritas Sedang, Alokasi Dinamis) ---
  BaseType_t xTask2Status = xTaskCreate(
      vBlueTask,
      "BlueTask",
      128,
      NULL,
      tskIDLE_PRIORITY + 1, // Prioritas sedang
      NULL
  );
  
  // Periksa keberhasilan pembuatan BlueTask
  if (xTask2Status == pdPASS) {
    printf("BlueTask berhasil dibuat.\n");
  } else {
    printf("ERROR: Gagal membuat BlueTask!\n");
  }

  // --- 3. Buat RedTask (Prioritas Sedang, Alokasi STATIK) ---
  TaskHandle_t xRedTaskHandle = xTaskCreateStatic(
      vRedTask,
      "RedTask",
      RED_TASK_STACK_SIZE,
      NULL,
      tskIDLE_PRIORITY + 1, // Prioritas sedang
      uxRedTaskStack,
      &xRedTaskTCB
  );

  // Periksa keberhasilan pembuatan RedTask
  if (xRedTaskHandle != NULL) {
    printf("RedTask (static) berhasil dibuat.\n\n");
  } else {
    printf("ERROR: Gagal membuat RedTask (static)!\n\n");
  }

  // --- 4. Jalankan scheduler ---
  printf("Memulai scheduler...\n");
  printf("----------------------------------\n");
  vTaskStartScheduler();

  // Kode di bawah ini tidak akan pernah dieksekusi
  while (1)
  {
  }
}

/**
  * @brief  Implementasi GreenTask
  */
void vGreenTask(void *pvParameters) {
  for (;;) {
    printf("Green Task is running... (High Prio)\n");
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}

/**
  * @brief  Implementasi BlueTask
  */
void vBlueTask(void *pvParameters) {
  for (;;) {
    printf("Blue Task is running... (Medium Prio)\n");
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}

/**
  * @brief  Implementasi RedTask
  */
void vRedTask(void *pvParameters) {
  for (;;) {
    printf("Red Task is running... (Medium Prio, Static)\n");
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}


// --- Implementasi Fungsi Inisialisasi (disederhanakan untuk Wokwi) ---

/**
  * @brief Mengarahkan printf ke UART
  */
#ifdef __GNUC__
int __io_putchar(int ch)
#else
int fputc(int ch, FILE *f)
#endif
{
  HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
  return ch;
}


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

  // Konfigurasi sumber clock internal (HSI)
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  // Konfigurasi clock untuk CPU, AHB, dan APB
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief USART2 Initialization Function
  */
static void MX_USART2_UART_Init(void)
{
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief GPIO Initialization Function
  */
static void MX_GPIO_Init(void)
{
  // Mengaktifkan clock untuk port GPIO
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
}


/**
  * @brief  This function is executed in case of error occurrence.
  */
void Error_Handler(void)
{
  __disable_irq();
  while (1)
  {
  }
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  * where the assert_param error has occurred.
  */
void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif