cmake_minimum_required(VERSION 3.1)
project(untitled)

set(THREADS_PREFER_PTHREAD_FLAG ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)

list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_SOURCE_DIR}/cmake")
include(CheckIncludeFile)
include(CMakePackageConfigHelpers)
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
include(CheckLinkerFlag)
include(CheckSymbolExists)

check_include_file(sys/prctl.h HAVE_SYS_PRCTL_H)
check_symbol_exists(prctl "sys/prctl.h" HAVE_PRCTL)

find_package(Qt5 REQUIRED COMPONENTS Core Widgets Gui Network Svg Xml WebSockets Quick Qml QuickControls2 QmlImportScanner)
qt5_add_resources(RESOURCES qml.qrc)

set(PROCESSOR_ARCH "64")
set(CMAKE_CXX_STANDARD 14)

# pthread
find_package(Threads REQUIRED)

function (add_c_flag_if_supported flag var)
    string(REPLACE "-" "_" supported ${flag}_c)
    check_c_compiler_flag(${flag} ${supported})
    if(${${supported}})
        set(${var} "${${var}} ${flag}" PARENT_SCOPE)
    endif()
endfunction()

function (add_cxx_flag_if_supported flag var)
    string(REPLACE "-" "_" supported ${flag}_cxx)
    check_cxx_compiler_flag(${flag} ${supported})
    if(${${supported}})
        set(${var} "${${var}} ${flag}" PARENT_SCOPE)
    endif()
endfunction()

function (add_linker_flag_if_supported flag var)
    string(REPLACE "-" "_" supported ${flag}_ld)
    string(REPLACE "," "_" supported ${flag}_ld)
    check_linker_flag(${flag} ${supported})
    if(${${supported}})
        set(${var} "${${var}} ${flag}" PARENT_SCOPE)
    endif()
endfunction()

if(MINGW)
    set(Boost_THREADAPI win32)
endif()

if(MINGW)
    string(REGEX MATCH "^[^/]:/[^/]*" msys2_install_path "${CMAKE_C_COMPILER}")
    message(STATUS "MSYS location: ${msys2_install_path}")
    set(CMAKE_INCLUDE_PATH "${msys2_install_path}/mingw${ARCH_WIDTH}/include")
    # This is necessary because otherwise CMake will make Boost libraries -lfoo
    # rather than a full path. Unfortunately, this makes the shared libraries get
    # linked due to a bug in CMake which misses putting -static flags around the
    # -lfoo arguments.
    set(DEFLIB ${msys2_install_path}/mingw${ARCH_WIDTH}/lib)
    list(REMOVE_ITEM CMAKE_C_IMPLICIT_LINK_DIRECTORIES ${DEFLIB})
    list(REMOVE_ITEM CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES ${DEFLIB})
endif()

if(MINGW)
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wa,-mbig-obj")
    set(EXTRA_LIBRARIES mswsock;ws2_32;iphlpapi;crypt32;bcrypt)
    if(DEPENDS)
        set(ICU_LIBRARIES iconv)
    else()
        set(ICU_LIBRARIES icuio icuin icuuc icudt icutu iconv)
    endif()
elseif(APPLE)
    set(EXTRA_LIBRARIES "-framework AppKit")
elseif(OPENBSD)
    set(EXTRA_LIBRARIES "")
elseif(FREEBSD)
    set(EXTRA_LIBRARIES execinfo)
elseif(DRAGONFLY)
    find_library(COMPAT compat)
    set(EXTRA_LIBRARIES execinfo ${COMPAT})
elseif(CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)")
    set(EXTRA_LIBRARIES socket nsl resolv)
elseif(NOT MSVC AND NOT DEPENDS)
    find_library(RT rt)
    set(EXTRA_LIBRARIES ${RT})
endif()

list(APPEND EXTRA_LIBRARIES ${CMAKE_DL_LIBS})

add_c_flag_if_supported(-Wformat C_SECURITY_FLAGS)
add_cxx_flag_if_supported(-Wformat CXX_SECURITY_FLAGS)
add_c_flag_if_supported(-Wformat-security C_SECURITY_FLAGS)
add_cxx_flag_if_supported(-Wformat-security CXX_SECURITY_FLAGS)

if (NOT OPENBSD AND NOT (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS 9.1)))
    add_c_flag_if_supported(-fstack-protector C_SECURITY_FLAGS)
    add_cxx_flag_if_supported(-fstack-protector CXX_SECURITY_FLAGS)
    add_c_flag_if_supported(-fstack-protector-strong C_SECURITY_FLAGS)
    add_cxx_flag_if_supported(-fstack-protector-strong CXX_SECURITY_FLAGS)
endif()

if (NOT OPENBSD AND NOT (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS 9.1)))
    add_c_flag_if_supported(-fcf-protection=full C_SECURITY_FLAGS)
    add_cxx_flag_if_supported(-fcf-protection=full CXX_SECURITY_FLAGS)
endif()

if (NOT (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 9.1))
    add_c_flag_if_supported(-mmitigate-rop C_SECURITY_FLAGS)
    add_cxx_flag_if_supported(-mmitigate-rop CXX_SECURITY_FLAGS)
endif()

if (NOT APPLE AND NOT (WIN32 AND CMAKE_C_COMPILER_ID STREQUAL "GNU"))
    # Windows binaries die on startup with PIE when compiled with GCC
    add_linker_flag_if_supported(-pie LD_SECURITY_FLAGS)
endif()
add_linker_flag_if_supported(-Wl,-z,relro LD_SECURITY_FLAGS)
add_linker_flag_if_supported(-Wl,-z,now LD_SECURITY_FLAGS)
add_linker_flag_if_supported(-Wl,-z,noexecstack noexecstack_SUPPORTED)
if (noexecstack_SUPPORTED)
    set(LD_SECURITY_FLAGS "${LD_SECURITY_FLAGS} -Wl,-z,noexecstack")
endif()
add_linker_flag_if_supported(-Wl,-z,noexecheap noexecheap_SUPPORTED)
if (noexecheap_SUPPORTED)
    set(LD_SECURITY_FLAGS "${LD_SECURITY_FLAGS} -Wl,-z,noexecheap")
endif()

# some windows linker bits
if (WIN32)
    add_linker_flag_if_supported(-Wl,--dynamicbase LD_SECURITY_FLAGS)
    add_linker_flag_if_supported(-Wl,--nxcompat LD_SECURITY_FLAGS)
    add_linker_flag_if_supported(-Wl,--high-entropy-va LD_SECURITY_FLAGS)
endif()

if(STATIC)
    message(STATUS "STATIC COMPILE ON")
    set(Boost_USE_STATIC_LIBS ON)
    set(Boost_USE_STATIC_RUNTIME ON)

    add_linker_flag_if_supported(-static-libgcc STATIC_FLAGS)
    add_linker_flag_if_supported(-static-libstdc++ STATIC_FLAGS)
    if(MINGW)
        message(STATUS "Mingw! :D")
        add_linker_flag_if_supported(-static STATIC_FLAGS)
    endif()
endif()

add_c_flag_if_supported(-fno-strict-aliasing C_SECURITY_FLAGS)
add_cxx_flag_if_supported(-fno-strict-aliasing CXX_SECURITY_FLAGS)

add_c_flag_if_supported(-fPIC C_SECURITY_FLAGS)
add_cxx_flag_if_supported(-fPIC CXX_SECURITY_FLAGS)

message(STATUS "Using C security hardening flags: ${C_SECURITY_FLAGS}")
message(STATUS "Using C++ security hardening flags: ${CXX_SECURITY_FLAGS}")
message(STATUS "Using linker security hardening flags: ${LD_SECURITY_FLAGS}")

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 ${C_SECURITY_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 ${CXX_SECURITY_FLAGS}")
message(STATUS "${STATIC_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LD_SECURITY_FLAGS} ${STATIC_FLAGS}")

add_definitions(-DVR_API_PUBLIC)
add_definitions(-DOPENVR_BUILD_STATIC)
add_subdirectory(contrib/openvr)

add_executable(untitled
        main.cpp
        openvroverlaycontroller.cpp
        openvroverlaycontroller.h
        overlaywidget.cpp
        overlaywidget.h
        ${RESOURCES}
        )

# OpenGL
target_include_directories(untitled PUBLIC ${OPENGL_INCLUDE_DIR})
message(STATUS "OpenGL: include dir at ${OPENGL_INCLUDE_DIR}")
message(STATUS "OpenGL: libraries at ${OPENGL_LIBRARIES}")

add_definitions(${QT_DEFINITIONS})
if(NOT "${CMAKE_BUILD_TYPE}" EQUAL "Debug")
    add_definitions(-DQT_NO_DEBUG)
endif()

target_compile_definitions(untitled PUBLIC VR_API_PUBLIC)

if(STATIC)
    target_compile_definitions(untitled PRIVATE STATIC=1)
endif()

target_include_directories(untitled PUBLIC
        ${Qt5Core_INCLUDE_DIRS}
        ${Qt5Widgets_INCLUDE_DIRS}
        ${Qt5Gui_INCLUDE_DIRS}
        ${Qt5Network_INCLUDE_DIRS}
        ${Qt5Svg_INCLUDE_DIRS}
        ${Qt5Xml_INCLUDE_DIRS}
        ${Qt5WebSockets_INCLUDE_DIRS}
        ${Qt5Quick_INCLUDE_DIRS}
        ${Qt5QuickControls2_INCLUDE_DIRS}
        ${Qt5Qml_INCLUDE_DIRS}

        ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
        ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
        ${Qt5QuickControls2_INCLUDE_DIRS}

        ${CMAKE_CURRENT_SOURCE_DIR}/contrib/openvr/headers
)

target_compile_definitions(untitled PUBLIC
        ${Qt5Core_DEFINITIONS}
        ${Qt5Widgets_DEFINITIONS}
        ${Qt5Gui_DEFINITIONS}
        ${Qt5Network_DEFINITIONS}
        ${Qt5Svg_DEFINITIONS}
        ${Qt5Xml_DEFINITIONS}
        ${Qt5Quick_DEFINITIONS}
        ${Qt5QuickControls2_DEFINITIONS}
        ${Qt5Qml_DEFINITIONS}
        ${Qt5WebSockets_DEFINITIONS}
)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")

message(STATUS "CMAKE_DL_LIBS ${CMAKE_DL_LIBS}")
message(STATUS "QT5_LIBRARIES ${QT5_LIBRARIES}")
message(STATUS "EXTRA_LIBRARIES ${EXTRA_LIBRARIES}")
message(STATUS "Qt5Qml_DEFINITIONS ${Qt5Qml_DEFINITIONS}")
message(STATUS "Qt5QuickControls2_DEFINITIONS ${Qt5QuickControls2_DEFINITIONS}")
message(STATUS "Qt5QuickControls2_INCLUDE_DIRS ${Qt5QuickControls2_INCLUDE_DIRS}")
message(STATUS "QSvgPlugin")

qt5_import_qml_plugins(${PROJECT_NAME})

target_link_libraries(untitled PUBLIC
        Qt5::Core
        Qt5::Widgets
        Qt5::Gui
        Qt5::Network
        Qt5::Svg
        Qt5::QSvgPlugin
        Qt5::QSvgIconPlugin
        Qt5::Xml
        Qt5::WebSockets
        Qt5::Quick
        Qt5::Qml
        Qt5::QuickControls2

        Threads::Threads
        ${CMAKE_DL_LIBS}
        ${EXTRA_LIBRARIES}
        )

if(MINGW)
    target_link_libraries(untitled PUBLIC
            openvr_api64
            gcc stdc++ winpthread ssp glu32 opengl32 glmf32 -dynamic)
else()
    target_link_libraries(untitled PUBLIC
            openvr_api)
endif()

set_target_properties(untitled
        PROPERTIES
        COMPILE_FLAGS "${QT_FLAGS}"
        )