name: TaskScheduler Unit Tests
on:
  push:
    branches: [ master, main ]
    paths:
      - 'examples/**'
      - 'src/**'
      - 'tests/**'
  pull_request:
    branches: [ master, main ]
    paths:
      - 'examples/**'
      - 'src/**'
      - 'tests/**'
  workflow_dispatch:

jobs:
  test-basic:
    name: Tests of Basic Functionality
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y cmake build-essential libgtest-dev pkg-config

      - name: Build and install Google Test
        run: |
          cd /usr/src/gtest
          sudo cmake .
          sudo cmake --build . --target all
          sudo cp lib/*.a /usr/lib || sudo cp *.a /usr/lib

      - name: Create CMakeLists.txt for Basic Tests
        run: |
          cat > CMakeLists.txt << 'EOF'
          cmake_minimum_required(VERSION 3.10)
          project(TaskSchedulerBasicTests VERSION 1.0.0)

          set(CMAKE_CXX_STANDARD 14)
          set(CMAKE_CXX_STANDARD_REQUIRED ON)

          # Find required packages
          find_package(PkgConfig REQUIRED)
          find_package(Threads REQUIRED)

          # Include directories
          include_directories(${CMAKE_SOURCE_DIR}/src)
          include_directories(${CMAKE_SOURCE_DIR}/tests)

          # Gather source files
          file(GLOB TASKSCHEDULER_SOURCES
              "${CMAKE_SOURCE_DIR}/src/*.cpp"
              "${CMAKE_SOURCE_DIR}/src/*.c"
          )

          # Create the basic test executable
          add_executable(test_basic
              tests/test-scheduler-basic.cpp
              ${TASKSCHEDULER_SOURCES}
          )

          # Link libraries
          target_link_libraries(test_basic
              gtest
              gtest_main
              pthread
          )

          # Compiler definitions for Arduino compatibility
          target_compile_definitions(test_basic PRIVATE
              ARDUINO=300
          )

          # Compiler flags
          target_compile_options(test_basic PRIVATE
              -Wall
              -Wextra
              -O2
          )

          # Enable testing
          enable_testing()
          add_test(NAME BasicTests COMMAND test_basic)
          EOF

      - name: Build basic tests
        run: |
          cmake .
          make -j$(nproc)

      - name: Run basic tests
        run: |
          echo "=== Running Basic Scheduler Tests ==="
          ./test_basic

  test-thorough:
    name: Thorough Scheduler Tests
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y cmake build-essential libgtest-dev pkg-config

      - name: Build and install Google Test
        run: |
          cd /usr/src/gtest
          sudo cmake .
          sudo cmake --build . --target all
          sudo cp lib/*.a /usr/lib || sudo cp *.a /usr/lib

      - name: Create CMakeLists.txt for Thorough  Tests
        run: |
          cat > CMakeLists.txt << 'EOF'
          cmake_minimum_required(VERSION 3.10)
          project(TaskSchedulerThoroughTests VERSION 1.0.0)

          set(CMAKE_CXX_STANDARD 14)
          set(CMAKE_CXX_STANDARD_REQUIRED ON)

          # Find required packages
          find_package(PkgConfig REQUIRED)
          find_package(Threads REQUIRED)

          # Include directories
          include_directories(${CMAKE_SOURCE_DIR}/src)
          include_directories(${CMAKE_SOURCE_DIR}/tests)

          # Gather source files
          file(GLOB TASKSCHEDULER_SOURCES
              "${CMAKE_SOURCE_DIR}/src/*.cpp"
              "${CMAKE_SOURCE_DIR}/src/*.c"
          )

          # Create the thorough test executable
          add_executable(test_thorough
              tests/test-scheduler-basic-thorough.cpp
              ${TASKSCHEDULER_SOURCES}
          )

          # Link libraries
          target_link_libraries(test_thorough
              gtest
              gtest_main
              pthread
          )

          # Compiler definitions for Arduino compatibility
          target_compile_definitions(test_thorough PRIVATE
              ARDUINO=300
          )

          # Compiler flags
          target_compile_options(test_thorough PRIVATE
              -Wall
              -Wextra
              -O2
          )

          # Enable testing
          enable_testing()
          add_test(NAME ThoroughTests COMMAND test_thorough)
          EOF

      - name: Build thorough tests
        run: |
          cmake .
          make -j$(nproc)

      - name: Run thorough tests
        run: |
          echo "=== Running Thorough Tests ==="
          ./test_thorough

  test-advanced:
    name: Tests of Advanced Functionality
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y cmake build-essential libgtest-dev pkg-config

      - name: Build and install Google Test
        run: |
          cd /usr/src/gtest
          sudo cmake .
          sudo cmake --build . --target all
          sudo cp lib/*.a /usr/lib || sudo cp *.a /usr/lib

      - name: Create CMakeLists.txt for Advanced Tests
        run: |
          cat > CMakeLists.txt << 'EOF'
          cmake_minimum_required(VERSION 3.10)
          project(TaskSchedulerAdvancedTests VERSION 1.0.0)

          set(CMAKE_CXX_STANDARD 14)
          set(CMAKE_CXX_STANDARD_REQUIRED ON)

          # Find required packages
          find_package(PkgConfig REQUIRED)
          find_package(Threads REQUIRED)

          # Include directories
          include_directories(${CMAKE_SOURCE_DIR}/src)
          include_directories(${CMAKE_SOURCE_DIR}/tests)

          # Gather source files
          file(GLOB TASKSCHEDULER_SOURCES
              "${CMAKE_SOURCE_DIR}/src/*.cpp"
              "${CMAKE_SOURCE_DIR}/src/*.c"
          )

          # Create the advanced test executable
          add_executable(test_advanced
              tests/test-scheduler-advanced-features.cpp
              ${TASKSCHEDULER_SOURCES}
          )

          # Link libraries
          target_link_libraries(test_advanced
              gtest
              gtest_main
              pthread
          )

          # Compiler definitions for Arduino compatibility
          target_compile_definitions(test_advanced PRIVATE
              ARDUINO=300
          )

          # Compiler flags
          target_compile_options(test_advanced PRIVATE
              -Wall
              -Wextra
              -O2
          )

          # Enable testing
          enable_testing()
          add_test(NAME AdvancedTests COMMAND test_advanced)
          EOF

      - name: Build advanced tests
        run: |
          cmake .
          make -j$(nproc)

      - name: Run advanced tests
        run: |
          echo "=== Running Advanced Tests ==="
          ./test_advanced

  test-blink-example:
    name: Tests Based on Blink Example
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y cmake build-essential libgtest-dev pkg-config

      - name: Build and install Google Test
        run: |
          cd /usr/src/gtest
          sudo cmake .
          sudo cmake --build . --target all
          sudo cp lib/*.a /usr/lib || sudo cp *.a /usr/lib

      - name: Create CMakeLists.txt for Blink Example Tests
        run: |
          cat > CMakeLists.txt << 'EOF'
          cmake_minimum_required(VERSION 3.10)
          project(TaskSchedulerBlinkExampleTests VERSION 1.0.0)

          set(CMAKE_CXX_STANDARD 14)
          set(CMAKE_CXX_STANDARD_REQUIRED ON)

          # Find required packages
          find_package(PkgConfig REQUIRED)
          find_package(Threads REQUIRED)

          # Include directories
          include_directories(${CMAKE_SOURCE_DIR}/src)
          include_directories(${CMAKE_SOURCE_DIR}/tests)

          # Gather source files
          file(GLOB TASKSCHEDULER_SOURCES
              "${CMAKE_SOURCE_DIR}/src/*.cpp"
              "${CMAKE_SOURCE_DIR}/src/*.c"
          )

          # Create the blink example test executable
          add_executable(test_blink_example
              tests/test-scheduler-blink-example.cpp
              ${TASKSCHEDULER_SOURCES}
          )

          # Link libraries
          target_link_libraries(test_blink_example
              gtest
              gtest_main
              pthread
          )

          # Compiler definitions for Arduino compatibility
          target_compile_definitions(test_blink_example PRIVATE
              ARDUINO=300
              _TASK_SLEEP_ON_IDLE_RUN
              _TASK_STATUS_REQUEST
          )

          # Compiler flags
          target_compile_options(test_blink_example PRIVATE
              -Wall
              -Wextra
              -O2
          )

          # Enable testing
          enable_testing()
          add_test(NAME BlinkExampleTests COMMAND test_blink_example)
          EOF

      - name: Build blink example tests
        run: |
          cmake .
          make -j$(nproc)

      - name: Run blink example tests
        run: |
          echo "=== Running Blink Example Tests ==="
          ./test_blink_example

  test-priority:
    name: Tests with Layered Priority
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y cmake build-essential libgtest-dev pkg-config

      - name: Build and install Google Test
        run: |
          cd /usr/src/gtest
          sudo cmake .
          sudo cmake --build . --target all
          sudo cp lib/*.a /usr/lib || sudo cp *.a /usr/lib

      - name: Create CMakeLists.txt for Priority Tests
        run: |
          cat > CMakeLists.txt << 'EOF'
          cmake_minimum_required(VERSION 3.10)
          project(TaskSchedulerPriorityTests VERSION 1.0.0)

          set(CMAKE_CXX_STANDARD 14)
          set(CMAKE_CXX_STANDARD_REQUIRED ON)

          # Find required packages
          find_package(PkgConfig REQUIRED)
          find_package(Threads REQUIRED)

          # Include directories
          include_directories(${CMAKE_SOURCE_DIR}/src)
          include_directories(${CMAKE_SOURCE_DIR}/tests)

          # Gather source files
          file(GLOB TASKSCHEDULER_SOURCES
              "${CMAKE_SOURCE_DIR}/src/*.cpp"
              "${CMAKE_SOURCE_DIR}/src/*.c"
          )

          # Create the priority test executable
          add_executable(test_priority
              tests/test-scheduler-priority.cpp
              ${TASKSCHEDULER_SOURCES}
          )

          # Link libraries
          target_link_libraries(test_priority
              gtest
              gtest_main
              pthread
          )

          # Compiler definitions for Arduino compatibility and priority support
          target_compile_definitions(test_priority PRIVATE
              ARDUINO=300
              _TASK_PRIORITY
          )

          # Compiler flags
          target_compile_options(test_priority PRIVATE
              -Wall
              -Wextra
              -O2
          )

          # Enable testing
          enable_testing()
          add_test(NAME PriorityTests COMMAND test_priority)
          EOF

      - name: Build priority tests
        run: |
          cmake .
          make -j$(nproc)

      - name: Run priority tests
        run: |
          echo "=== Running Priority Tests ==="
          ./test_priority

  test-thread-safe:
    name: Tests of Thread-Safe Functionality
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y cmake build-essential libgtest-dev pkg-config

      - name: Build and install Google Test
        run: |
          cd /usr/src/gtest
          sudo cmake .
          sudo cmake --build . --target all
          sudo cp lib/*.a /usr/lib || sudo cp *.a /usr/lib

      - name: Create CMakeLists.txt for Thread-Safe Tests
        run: |
          cat > CMakeLists.txt << 'EOF'
          cmake_minimum_required(VERSION 3.10)
          project(TaskSchedulerThreadSafeTests VERSION 1.0.0)

          set(CMAKE_CXX_STANDARD 14)
          set(CMAKE_CXX_STANDARD_REQUIRED ON)

          # Find required packages
          find_package(PkgConfig REQUIRED)
          find_package(Threads REQUIRED)

          # Include directories
          include_directories(${CMAKE_SOURCE_DIR}/src)
          include_directories(${CMAKE_SOURCE_DIR}/tests)

          # Gather source files
          file(GLOB TASKSCHEDULER_SOURCES
              "${CMAKE_SOURCE_DIR}/src/*.cpp"
              "${CMAKE_SOURCE_DIR}/src/*.c"
          )

          # Create the thread-safe test executable
          add_executable(test_thread_safe
              tests/test-scheduler-thread-safe.cpp
              tests/test-queue-impl.cpp
              ${TASKSCHEDULER_SOURCES}
          )

          # Link libraries
          target_link_libraries(test_thread_safe
              gtest
              gtest_main
              pthread
          )

          # Compiler definitions for Arduino compatibility and thread safety
          target_compile_definitions(test_thread_safe PRIVATE
              ARDUINO=300
              _TASK_HEADER_AND_CPP
              _TASK_THREAD_SAFE
              _TASK_STATUS_REQUEST
              _TASK_TIMEOUT
          )

          # Compiler flags
          target_compile_options(test_thread_safe PRIVATE
              -Wall
              -Wextra
              -O2
              -pthread
          )

          # Enable testing
          enable_testing()
          add_test(NAME ThreadSafeTests COMMAND test_thread_safe)
          EOF

      - name: Build thread-safe tests
        run: |
          cmake .
          make -j$(nproc)

      - name: Run thread-safe tests
        run: |
          echo "=== Running Thread-Safe Tests ==="
          ./test_thread_safe