# Copyright (c) 2025 Dominic Masters
# 
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT

# Setup
cmake_minimum_required(VERSION 3.13)
set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)

option(ENABLE_TESTS "Enable tests" OFF)

# Prep cache
set(DUSK_CACHE_TARGET "dusk-target")

# Build variables
set(DUSK_ROOT_DIR "${CMAKE_SOURCE_DIR}")
set(DUSK_BUILD_DIR "${CMAKE_BINARY_DIR}")
set(DUSK_SOURCES_DIR "${DUSK_ROOT_DIR}/src")
set(DUSK_TEST_DIR "${DUSK_ROOT_DIR}/test")
set(DUSK_TEMP_DIR "${DUSK_BUILD_DIR}/temp")
set(DUSK_TOOLS_DIR "${DUSK_ROOT_DIR}/tools")
set(DUSK_DATA_DIR "${DUSK_ROOT_DIR}/data")
set(DUSK_ASSETS_DIR "${DUSK_ROOT_DIR}/assets")
set(DUSK_BUILT_ASSETS_DIR "${DUSK_BUILD_DIR}/built_assets" CACHE INTERNAL ${DUSK_CACHE_TARGET})
set(DUSK_GENERATED_HEADERS_DIR "${DUSK_BUILD_DIR}/generated")
set(DUSK_BUILD_BINARY ${DUSK_BUILD_DIR}/Dusk CACHE INTERNAL ${DUSK_CACHE_TARGET})
set(DUSK_ASSETS "" CACHE INTERNAL ${DUSK_CACHE_TARGET})
set(DUSK_LIBRARY_TARGET_NAME "DuskCore" CACHE INTERNAL ${DUSK_CACHE_TARGET})
set(DUSK_BINARY_TARGET_NAME "Dusk" CACHE INTERNAL ${DUSK_CACHE_TARGET})

# Create directories
file(MAKE_DIRECTORY ${DUSK_GENERATED_HEADERS_DIR})

# Find packages
find_package(Python3 COMPONENTS Interpreter REQUIRED)

# Set target system
# message(FATAL_ERROR "DISABLED FOR NOW2 ${DUSK_TARGET_SYSTEM}") 

if(NOT DEFINED DUSK_TARGET_SYSTEM)
  set(DUSK_TARGET_SYSTEM "linux")
endif()

# Toolchains
if(DUSK_TARGET_SYSTEM STREQUAL "psp")
  find_package(pspsdk REQUIRED)
endif()

if(DUSK_TARGET_SYSTEM STREQUAL "gamecube" OR DUSK_TARGET_SYSTEM STREQUAL "wii")
  # Override to make library and binary be the same.
  set(DUSK_LIBRARY_TARGET_NAME "${DUSK_LIBRARY_TARGET_NAME}.elf" CACHE INTERNAL ${DUSK_CACHE_TARGET})
endif()

# Init Project.
project(${DUSK_LIBRARY_TARGET_NAME}
  VERSION 1.0.0
  LANGUAGES C CXX
)

# Either, create library and binary separately (used for tests), or make them
# one in the same so all code is in the binary.
if(ENABLE_TESTS)
  # MainLibrary
  add_library(${DUSK_LIBRARY_TARGET_NAME} STATIC)

  # Binary Executable
  add_executable(${DUSK_BINARY_TARGET_NAME} ${DUSK_SOURCES_DIR}/null.c)

  # Link library to binary
  target_link_libraries(${DUSK_BINARY_TARGET_NAME}
    PUBLIC
      ${DUSK_LIBRARY_TARGET_NAME}
  )
else()
  set(DUSK_BINARY_TARGET_NAME "${DUSK_LIBRARY_TARGET_NAME}" CACHE INTERNAL ${DUSK_CACHE_TARGET})
  add_executable(${DUSK_BINARY_TARGET_NAME} src2/main.cpp)
endif()

# Add tools
add_subdirectory(tools)

# Assets
add_subdirectory(assets)

# Add libraries
if(DUSK_TARGET_SYSTEM STREQUAL "linux")
  find_package(SDL2 REQUIRED)
  find_package(OpenGL REQUIRED)
  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC 
    SDL2
    pthread
    OpenGL::GL
    GL
    m
  )

elseif(DUSK_TARGET_SYSTEM STREQUAL "psp")
  find_package(SDL2 REQUIRED)
  find_package(OpenGL REQUIRED)
  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
    ${SDL2_LIBRARIES}
    SDL2
    pthread
    OpenGL::GL
    zip
    bz2
    z
    mbedtls
    mbedcrypto
    lzma
    m
  )
  target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
    ${SDL2_INCLUDE_DIRS}
  )

elseif(DUSK_TARGET_SYSTEM STREQUAL "gamecube" OR DUSK_TARGET_SYSTEM STREQUAL "wii")
  if(NOT DEFINED ENV{DEVKITPPC})
    message(FATAL_ERROR "DEVKITPPC environment variable not set!")
  endif()
  set(DEVKITPPC $ENV{DEVKITPPC})
  if(NOT DEFINED ENV{DEVKITPRO})
    message(FATAL_ERROR "DEVKITPRO environment variable not set!")
  endif()
  set(DEVKITPRO $ENV{DEVKITPRO})

  # set(CMAKE_C_COMPILER   "${DEVKITPPC}/bin/powerpc-eabi-gcc")
  # string(APPEND CMAKE_C_FLAGS "-g -O2 -mcpu=750 -meabi -mhard-float -Wall -mogc -DGEKKO")

  set(CMAKE_FIND_ROOT_PATH "${DEVKITPRO}" "${DEVKITPPC}")
  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
  set(CMAKE_SKIP_RPATH TRUE)
  set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
  set(CMAKE_INSTALL_RPATH "")

  set(PORTLIBS_PATH "${DEVKITPRO}/portlibs")

  if(DUSK_TARGET_SYSTEM STREQUAL "gamecube")
    set(_PORTLIBS_FLAVOR "gamecube")
    set(_LIBOGC_LIBDIR "${DEVKITPRO}/libogc/lib/cube")
    target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PRIVATE GEKKO HW_DOL GAMECUBE DOLPHIN)
    set(_MACHDEP_OPTS -mogc -mcpu=750 -meabi -mhard-float)
  else()
    set(_PORTLIBS_FLAVOR "wii")
    set(_LIBOGC_LIBDIR "${DEVKITPRO}/libogc/lib/wii")
    target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PRIVATE GEKKO HW_RVL WII DOLPHIN)
    set(_MACHDEP_OPTS -mrvll -mcpu=750 -meabi -mhard-float)
  endif()

  target_compile_options(${DUSK_LIBRARY_TARGET_NAME} PRIVATE ${_MACHDEP_OPTS} -Wall -O2)
  target_link_options(${DUSK_LIBRARY_TARGET_NAME} PRIVATE ${_MACHDEP_OPTS})

  target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
    "${DEVKITPRO}/libogc/include"
    "${PORTLIBS_PATH}/${_PORTLIBS_FLAVOR}/include"
    "${PORTLIBS_PATH}/${_PORTLIBS_FLAVOR}/include/SDL2"
    "${PORTLIBS_PATH}/ppc/include"
  )

  target_link_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
    "${_LIBOGC_LIBDIR}"
    "${PORTLIBS_PATH}/${_PORTLIBS_FLAVOR}/lib"
    "${PORTLIBS_PATH}/ppc/lib"
  )
  

  set(Lua_FOUND TRUE)
  set(libzip_FOUND TRUE)

  # Custom flags for cglm
  set(CGLM_SHARED OFF CACHE BOOL "Build cglm shared" FORCE)
  set(CGLM_STATIC ON  CACHE BOOL "Build cglm static" FORCE)
  find_package(cglm REQUIRED)

  # Compile lua
  include(FetchContent)
  FetchContent_Declare(
    liblua
    URL https://www.lua.org/ftp/lua-5.5.0.tar.gz
  )
  FetchContent_MakeAvailable(liblua)
  set(LUA_SRC_DIR "${liblua_SOURCE_DIR}/src")
  set(LUA_C_FILES 
    lapi.c lauxlib.c lbaselib.c lcode.c lcorolib.c lctype.c ldblib.c ldebug.c
    ldo.c ldump.c lfunc.c lgc.c linit.c liolib.c llex.c lmathlib.c lmem.c
    loadlib.c lobject.c lopcodes.c loslib.c lparser.c lstate.c lstring.c
    lstrlib.c ltable.c ltablib.c ltm.c lundump.c lutf8lib.c lvm.c lzio.c
  )
  list(TRANSFORM LUA_C_FILES PREPEND "${LUA_SRC_DIR}/")
  add_library(liblua STATIC ${LUA_C_FILES})
  target_include_directories(liblua PUBLIC "${LUA_SRC_DIR}")
  target_compile_definitions(liblua PRIVATE LUA_USE_C89)
  add_library(lua::lua ALIAS liblua)
  
  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
    # cglm
    # liblua

    # zip
    # bz2
    # z
    
    SDL2
    SDL2_gfx
    pthread

    aesnd
    opengx
    gxflux
    
    fat
    ogc
    m
    opus
  )
endif()

# Force turn tests off for now
set(ENABLE_TESTS OFF CACHE BOOL "Enable tests" FORCE)

# Add code
add_subdirectory(src2)

# Handle tests
if(ENABLE_TESTS)
  enable_testing()
  add_subdirectory(test)
endif()

# Build assets
dusk_run_python(
  DUSK_ASSETS_BUILT
  tools.asset.bundle
    --assets ${DUSK_ASSETS_DIR}
    --output-assets ${DUSK_BUILT_ASSETS_DIR}
    --output-file ${DUSK_BUILD_DIR}/dusk.dsk
    --headers-dir ${DUSK_GENERATED_HEADERS_DIR}
    --input ${DUSK_ASSETS}
)
add_dependencies(${DUSK_LIBRARY_TARGET_NAME} DUSK_ASSETS_BUILT)

# Include generated headers
target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
  ${DUSK_GENERATED_HEADERS_DIR}
)

# Postbuild
if(DUSK_TARGET_SYSTEM STREQUAL "psp")
  create_pbp_file(
    TARGET "${DUSK_BINARY_TARGET_NAME}"
    ICON_PATH NULL
    BACKGROUND_PATH NULL
    PREVIEW_PATH NULL
    TITLE "${DUSK_BINARY_TARGET_NAME}"
    PSAR_PATH ${DUSK_BUILD_DIR}/dusk.dsk
    VERSION 01.00
  )
elseif(DUSK_TARGET_SYSTEM STREQUAL "gamecube" OR DUSK_TARGET_SYSTEM STREQUAL "wii")
  set(DUSK_BINARY_TARGET_NAME_DOL "${DUSK_BUILD_DIR}/Dusk.dol")
  add_custom_command(TARGET ${DUSK_BINARY_TARGET_NAME} POST_BUILD
    COMMAND elf2dol
            "$<TARGET_FILE:${DUSK_BINARY_TARGET_NAME}>"
            "${DUSK_BINARY_TARGET_NAME_DOL}"
    COMMENT "Generating ${DUSK_BINARY_TARGET_NAME_DOL} from ${DUSK_BINARY_TARGET_NAME}"
  )
endif()