# 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} ${DUSK_SOURCES_DIR}/null.c)
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})

  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 HW_DOL GAMECUBE)
    set(_MACHDEP_OPTS -mogc)
  else()
    set(_PORTLIBS_FLAVOR "wii")
    set(_LIBOGC_LIBDIR "${DEVKITPRO}/libogc/lib/wii")
    target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PRIVATE HW_RVL WII)
    set(_MACHDEP_OPTS -mrvll)
  endif()
  target_compile_options(${DUSK_LIBRARY_TARGET_NAME} PRIVATE ${_MACHDEP_OPTS} -DGEKKO -DDOLPHIN -Wall -O2 -DSDL_MAIN_HANDLED -meabi -mhard-float -g -mcpu=750)
  target_link_options(${DUSK_LIBRARY_TARGET_NAME} PRIVATE ${_MACHDEP_OPTS} -DGEKKO -DDOLPHIN -Wall -O2 -DSDL_MAIN_HANDLED  -meabi -mhard-float -g -mcpu=750)

  execute_process(
    COMMAND /opt/devkitpro/portlibs/${_PORTLIBS_FLAVOR}/bin/powerpc-eabi-pkg-config --libs sdl2 SDL2_ttf SDL2_gfx SDL2_mixer SDL2_image
    OUTPUT_VARIABLE PKG_CONFIG_LIBS
    OUTPUT_STRIP_TRAILING_WHITESPACE
  )
  # message(FATAL_ERROR "DISABLED FOR NOW ${PKG_CONFIG_LIBS}")
  target_compile_options(${DUSK_LIBRARY_TARGET_NAME} PUBLIC ${PKG_CONFIG_LIBS})
  target_link_options(${DUSK_LIBRARY_TARGET_NAME} PUBLIC ${PKG_CONFIG_LIBS})

  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} PUBLIC
    # cglm
    # liblua

    # zip
    # bz2
    # z

    SDL2_ttf
    m
    harfbuzz

    SDL2_gfx

    SDL2_mixer
    m
    stdc++
    ogg
    vorbisidec
    modplug
    mpg123
    opusfile
    opus
    FLAC

    SDL2_image
    SDL2main
    SDL2
    pthread
    
    aesnd
    opengx
    fat
    ogc
    png16
    z
    jpeg
    freetype
  )
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()