cmake_minimum_required(VERSION 3.5)

#

# Create a single baseset meta file with the correct translations.

#

set(ARGC 1)

set(ARG_READ NO)

# Read all the arguments given to CMake; we are looking for -- and everything

# that follows. Those are our language files.

while(ARGC LESS CMAKE_ARGC)

    set(ARG ${CMAKE_ARGV${ARGC}})

    if (ARG_READ)

        list(APPEND LANG_SOURCE_FILES "${ARG}")

    endif (ARG_READ)

    if (ARG STREQUAL "--")

        set(ARG_READ YES)

    endif (ARG STREQUAL "--")

    math(EXPR ARGC "${ARGC} + 1")

endwhile()

# Place holder format is @<ini_key>_<str_id>@

file(STRINGS "${BASESET_SOURCE_FILE}" PLACE_HOLDER REGEX "^@")

string(REGEX REPLACE "@([^_]+).*@" "\\1" INI_KEY "${PLACE_HOLDER}")

string(REGEX REPLACE "@[^_]+_(.*)@" "\\1" STR_ID "${PLACE_HOLDER}")

string(REGEX REPLACE "@(.*)@" "\\1" PLACE_HOLDER "${PLACE_HOLDER}")

# Get the translations

foreach(LANGFILE IN LISTS LANG_SOURCE_FILES)

    file(STRINGS "${LANGFILE}" LANGLINES REGEX "^(##isocode|${STR_ID})" ENCODING UTF-8)

    string(FIND "${LANGLINES}" "${STR_ID}" HAS_STR_ID)

    if (HAS_STR_ID LESS 0)

        continue()

    endif (HAS_STR_ID LESS 0)

    string(REGEX REPLACE "##isocode ([^;]+).*" "\\1" ISOCODE "${LANGLINES}")

    if ("${ISOCODE}" STREQUAL "en_GB")

        string(REGEX REPLACE "[^:]*:(.*)" "${INI_KEY}       = \\1" LANGLINES "${LANGLINES}")

    else()

        string(REGEX REPLACE "[^:]*:(.*)" "${INI_KEY}.${ISOCODE} = \\1" LANGLINES "${LANGLINES}")

    endif()

    list(APPEND ${PLACE_HOLDER} ${LANGLINES})

endforeach(LANGFILE)

list(SORT ${PLACE_HOLDER})

string(REPLACE ";" "\n" ${PLACE_HOLDER} "${${PLACE_HOLDER}}")

# Get the grf md5

file(MD5 ${BASESET_EXTRAGRF_FILE} ORIG_EXTRA_GRF_MD5)

configure_file(${BASESET_SOURCE_FILE} ${BASESET_BINARY_FILE})

cmake_minimum_required(VERSION 3.5)

#

# Create a single GRF file based on sprites/<grfname>.nfo and sprites/*.png

# files.

#

if (NOT NFORENUM_EXECUTABLE)

    message(FATAL_ERROR "Script needs NFORENUM_EXECUTABLE defined")

endif (NOT NFORENUM_EXECUTABLE)

if (NOT GRFCODEC_EXECUTABLE)

    message(FATAL_ERROR "Script needs GRFCODEC_EXECUTABLE defined")

endif (NOT GRFCODEC_EXECUTABLE)

if (NOT GRF_SOURCE_FOLDER)

    message(FATAL_ERROR "Script needs GRF_SOURCE_FOLDER defined")

endif (NOT GRF_SOURCE_FOLDER)

if (NOT GRF_BINARY_FILE)

    message(FATAL_ERROR "Script needs GRF_BINARY_FILE defined")

endif (NOT GRF_BINARY_FILE)

get_filename_component(GRF_SOURCE_FOLDER_NAME "${GRF_SOURCE_FOLDER}" NAME)

file(WRITE sprites/${GRF_SOURCE_FOLDER_NAME}.nfo "")

file(READ ${GRF_SOURCE_FOLDER}/${GRF_SOURCE_FOLDER_NAME}.nfo NFO_LINES)

# Replace ; with \;, and make a list out of this based on \n

string(REPLACE ";" "\\;" NFO_LINES "${NFO_LINES}")

string(REPLACE "\n" ";" NFO_LINES "${NFO_LINES}")

foreach(NFO_LINE IN LISTS NFO_LINES)

    # Recover the ; that was really in the text (and not a newline)

    string(REPLACE "\\;" ";" NFO_LINE "${NFO_LINE}")

    if (NFO_LINE MATCHES "^#include")

        string(REGEX REPLACE "^#include \"(.*)\"$" "\\1" INCLUDE_FILE ${NFO_LINE})

        file(READ ${GRF_SOURCE_FOLDER}/${INCLUDE_FILE} INCLUDE_LINES)

        file(APPEND sprites/${GRF_SOURCE_FOLDER_NAME}.nfo "${INCLUDE_LINES}")

    else (NFO_LINE MATCHES "^#include")

        file(APPEND sprites/${GRF_SOURCE_FOLDER_NAME}.nfo "${NFO_LINE}\n")

    endif (NFO_LINE MATCHES "^#include")

endforeach(NFO_LINE)

execute_process(COMMAND ${NFORENUM_EXECUTABLE} -s sprites/${GRF_SOURCE_FOLDER_NAME}.nfo)

execute_process(COMMAND ${GRFCODEC_EXECUTABLE} -n -s -e -p1 ${GRF_SOURCE_FOLDER_NAME}.grf)

execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${GRF_SOURCE_FOLDER_NAME}.grf ${GRF_BINARY_FILE})

add_subdirectory(openttd)

add_subdirectory(orig_extra)

set(BASESET_SOURCE_FILES

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_dos.obg

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_dos_de.obg

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_win.obg

        ${CMAKE_CURRENT_SOURCE_DIR}/no_music.obm

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_dos.obm

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_tto.obm

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_win.obm

        ${CMAKE_CURRENT_SOURCE_DIR}/no_sound.obs

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_dos.obs

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_win.obs

)

set(BASESET_OTHER_SOURCE_FILES

        ${CMAKE_CURRENT_SOURCE_DIR}/openttd.grf

        ${CMAKE_CURRENT_SOURCE_DIR}/opntitle.dat

        ${CMAKE_CURRENT_SOURCE_DIR}/orig_extra.grf

)

# Done by the subdirectories, if nforenum / grfcodec is installed

if (NFORENUM_FOUND AND GRFCODEC_FOUND)

    set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/openttd.grf PROPERTIES GENERATED TRUE)

    set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/orig_extra.grf PROPERTIES GENERATED TRUE)

    list(APPEND BASESET_BINARY_FILES openttd.grf)

    list(APPEND BASESET_BINARY_FILES orig_extra.grf)

endif (NFORENUM_FOUND AND GRFCODEC_FOUND)

set(BASESET_EXTRAGRF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/orig_extra.grf)

# Walk over all the baseset files, and generate a command to configure them

foreach(BASESET_SOURCE_FILE IN LISTS BASESET_SOURCE_FILES)

    get_filename_component(BASESET_SOURCE_FILE_NAME "${BASESET_SOURCE_FILE}" NAME)

    set(BASESET_BINARY_FILE "${CMAKE_BINARY_DIR}/baseset/${BASESET_SOURCE_FILE_NAME}")

    get_target_property(LANG_SOURCE_FILES language_files LANG_SOURCE_FILES)

    add_custom_command_timestamp(OUTPUT ${BASESET_BINARY_FILE}

            COMMAND ${CMAKE_COMMAND}

                    -DBASESET_SOURCE_FILE=${BASESET_SOURCE_FILE}

                    -DBASESET_BINARY_FILE=${BASESET_BINARY_FILE}

                    -DBASESET_EXTRAGRF_FILE=${BASESET_EXTRAGRF_FILE}

                    -P ${CMAKE_SOURCE_DIR}/cmake/scripts/Baseset.cmake

                    --

                    ${LANG_SOURCE_FILES}

            MAIN_DEPENDENCY ${BASESET_SOURCE_FILE}

            DEPENDS ${LANG_SOURCE_FILES}

                    ${BASESET_EXTRAGRF_FILE}

                    ${CMAKE_SOURCE_DIR}/cmake/scripts/Baseset.cmake

            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

            COMMENT "Generating ${BASESET_SOURCE_FILE_NAME} baseset metadata file"

    )

    list(APPEND BASESET_BINARY_FILES ${BASESET_BINARY_FILE})

endforeach(BASESET_SOURCE_FILE)

# Walk over all the other baseset files, and generate a command to copy them

foreach(BASESET_OTHER_SOURCE_FILE IN LISTS BASESET_OTHER_SOURCE_FILES)

    get_filename_component(BASESET_OTHER_SOURCE_FILE_NAME "${BASESET_OTHER_SOURCE_FILE}" NAME)

    set(BASESET_OTHER_BINARY_FILE "${CMAKE_BINARY_DIR}/baseset/${BASESET_OTHER_SOURCE_FILE_NAME}")

    add_custom_command(OUTPUT ${BASESET_OTHER_BINARY_FILE}

            COMMAND ${CMAKE_COMMAND} -E copy

                    ${BASESET_OTHER_SOURCE_FILE}

                    ${BASESET_OTHER_BINARY_FILE}

            MAIN_DEPENDENCY ${BASESET_OTHER_SOURCE_FILE}

            COMMENT "Copying ${BASESET_OTHER_SOURCE_FILE_NAME} baseset file"

    )

    list(APPEND BASESET_BINARY_FILES ${BASESET_OTHER_BINARY_FILE})

endforeach(BASESET_OTHER_SOURCE_FILE)

# Create a new target which generates all baseset metadata files

add_custom_target_timestamp(baseset_files

        DEPENDS

        ${BASESET_BINARY_FILES}

)

add_library(basesets

        INTERFACE

)

add_dependencies(basesets

        baseset_files

)

add_library(openttd::basesets ALIAS basesets)

@description_STR_BASEMUSIC_NONE_DESCRIPTION@

@description_STR_BASESOUNDS_NONE_DESCRIPTION@