# ----------------------- #
#  Project Configuration  #
# ----------------------- #
project(
  'draconis++',
  'cpp',
  version: '0.1.0',
  default_options: [
    'default_library=static',
    'buildtype=debugoptimized',
    'b_vscrt=mt',
    'b_lto=true',
    'b_ndebug=if-release',
    'warning_level=3',
  ],
)

cpp = meson.get_compiler('cpp')
host_system = host_machine.system()

# ------------------------ #
#  Compiler Configuration  #
# ------------------------ #
common_warning_flags = [
  '-Wno-c++20-compat',
  '-Wno-c++20-extensions',
  '-Wno-c++98-compat',
  '-Wno-c++98-compat-pedantic',
  '-Wno-disabled-macro-expansion',
  '-Wno-missing-prototypes',
  '-Wno-padded',
  '-Wno-pre-c++20-compat-pedantic',
  '-Wno-unused-command-line-argument',
  '-Wunused-function',
]

common_cpp_flags = {
  'common': [
    '-fno-strict-enums',
    '-fvisibility=hidden',
    '-fvisibility-inlines-hidden',
    '-std=c++26',
  ],
  'msvc': [
    '-DNOMINMAX', '/MT',
    '/Zc:__cplusplus',
    '/Zc:preprocessor',
    '/external:W0',
    '/external:anglebrackets',
    '/std:c++latest',
  ],
  'unix_extra': '-march=native',
  'windows_extra': '-DCURL_STATICLIB',
}

# Configure Objective-C++ for macOS
if host_system == 'darwin'
  add_languages('objcpp', native: false)
  objcpp = meson.get_compiler('objcpp')
  objcpp_flags = common_warning_flags + [
    '-std=c++26',
    '-fvisibility=hidden',
    '-fvisibility-inlines-hidden',
  ]
  add_project_arguments(objcpp.get_supported_arguments(objcpp_flags), language: 'objcpp')
endif

# Apply C++ compiler arguments
if cpp.get_id() in ['msvc', 'clang-cl']
  common_cpp_args = common_cpp_flags['msvc']
  if cpp.get_id() == 'clang-cl'
    common_cpp_args += common_warning_flags + common_cpp_flags['common'] + ['-fcolor-diagnostics', '-fdiagnostics-format=clang']
  endif
else
  common_cpp_args = common_warning_flags + common_cpp_flags['common']
  if host_system == 'windows'
    common_cpp_args += common_cpp_flags['windows_extra']
  elif host_system != 'serenity'
    common_cpp_args += common_cpp_flags['unix_extra']
  endif
endif

add_project_arguments(common_cpp_args, language: 'cpp')

# ------- #
#  Files  #
# ------- #
base_sources = files(
  'src/config/config.cpp',
  'src/config/weather.cpp',
  'src/core/package.cpp',
  'src/core/system_data.cpp',
  'src/main.cpp',
  'src/ui/ui.cpp',
)

platform_sources = {
  'darwin': ['src/os/macos.cpp', 'src/os/macos/bridge.mm'],
  'dragonfly': ['src/os/bsd.cpp'],
  'freebsd': ['src/os/bsd.cpp'],
  'haiku': ['src/os/haiku.cpp'],
  'linux': ['src/os/linux.cpp'],
  'netbsd': ['src/os/bsd.cpp'],
  'serenity': ['src/os/serenity.cpp'],
  'windows': ['src/os/windows.cpp'],
}

sources = base_sources + files(platform_sources.get(host_system, []))

# --------------------- #
#  Dependencies Config  #
# --------------------- #
common_deps = [
  dependency('libcurl', include_type: 'system', static: true),
  dependency('tomlplusplus', include_type: 'system', static: true),
  dependency('openssl', include_type: 'system', static: true, required: false),
]

# Platform-specific dependencies
platform_deps = []

if host_system == 'darwin'
  platform_deps += [
    dependency('SQLiteCpp'),
    dependency(
      'appleframeworks',
      modules: ['foundation', 'mediaplayer', 'systemconfiguration'],
      static: true,
    ),
    dependency('iconv'),
  ]
elif host_system == 'windows'
  platform_deps += [
    cpp.find_library('dwmapi'),
    cpp.find_library('windowsapp'),
  ]
elif host_system != 'serenity' and host_system != 'haiku'
  # Make dbus, x11, and wayland dependencies optional
  dbus_dep = dependency('dbus-1', required: false)
  xcb_dep = dependency('xcb', required: false)
  xau_dep = dependency('xau', required: false)
  xdmcp_dep = dependency('xdmcp', required: false)
  wayland_dep = dependency('wayland-client', required: false)

  platform_deps += [
    dependency('SQLiteCpp'),
    dependency('pugixml'),
  ]

  if dbus_dep.found()
    platform_deps += dbus_dep
    add_project_arguments('-DHAVE_DBUS', language: 'cpp')
  endif
  if xcb_dep.found() and xau_dep.found() and xdmcp_dep.found()
    platform_deps += [xcb_dep, xau_dep, xdmcp_dep]
    add_project_arguments('-DHAVE_XCB', language: 'cpp')
  endif
  if wayland_dep.found()
    platform_deps += wayland_dep
    add_project_arguments('-DHAVE_WAYLAND', language: 'cpp')
  endif
endif

# FTXUI configuration
ftxui_components = ['ftxui::screen', 'ftxui::dom', 'ftxui::component']
ftxui_dep = dependency(
  'ftxui',
  modules: ftxui_components,
  include_type: 'system',
  static: true,
  required: false,
)

if not ftxui_dep.found()
  ftxui_dep = declare_dependency(
    dependencies: [
      dependency('ftxui-dom', fallback: ['ftxui', 'dom_dep']),
      dependency('ftxui-screen', fallback: ['ftxui', 'screen_dep']),
      dependency('ftxui-component', fallback: ['ftxui', 'component_dep']),
    ],
  )
endif

glaze_dep = dependency('glaze', include_type: 'system', required: false)

if not glaze_dep.found()
  cmake = import('cmake')
  glaze_proj = cmake.subproject('glaze')
  glaze_dep = glaze_proj.dependency('glaze_glaze', include_type: 'system')
endif

# Combine all dependencies
deps = common_deps + platform_deps + ftxui_dep + glaze_dep

# ------------------------- #
#  Link/ObjC Configuration  #
# ------------------------- #
link_args = []
objc_args = []

if host_system == 'darwin'
  objc_args += ['-fobjc-arc']
elif host_system == 'linux'
  link_args += ['-static']
elif host_system == 'haiku'
  link_args += ['-lpackage', '-lbe']
endif

# ------------------- #
#  Executable Target  #
# ------------------- #
executable(
  'draconis++',
  sources,
  objc_args: objc_args,
  link_args: link_args,
  dependencies: deps,
  install: true,
)