#!/usr/bin/env python
import os

Import("env")

def build_lexy(env):
    env.Append(CPPDEFINES=["LEXY_HAS_UNICODE_DATABASE=1"])
    lexy_env = env.Clone()

    # Require C++20
    if lexy_env.get("is_msvc", False):
        lexy_env.Append(CXXFLAGS=["/std:c++20"])

        lexy_env.Append(CXXFLAGS=["/WX", "/W3", "/D", "_CRT_SECURE_NO_WARNINGS"])
        if not lexy_env.get("use_clang_cl"):
            lexy_env.Append(CXXFLAGS=["/wd5105"])
    else:
        lexy_env.Append(CXXFLAGS=["-std=c++20"])

        lexy_env.Append(CXXFLAGS=["-pedantic-errors", "-Werror", "-Wall", "-Wextra", "-Wconversion", "-Wsign-conversion"])
        if lexy_env["CXX"] == "clang++":
            lexy_env.Append(CXXFLAGS=["-Wno-shift-op-parentheses", "-Wno-parentheses-equality"])
        else:
            lexy_env.Append(CXXFLAGS=[
                "-Wno-parentheses", "-Wno-unused-local-typedefs", "-Wno-array-bounds" #, "-Wno-maybe-uninitialized", "-Wno-restrict"
            ])

    include_path = "lexy/include"
    source_path = "lexy/src"
    lexy_env.Append(CPPPATH=[[lexy_env.Dir(p) for p in [source_path, include_path]]])
    sources = env.GlobRecursive("*.cpp", [source_path])
    env.lexy_sources = sources

    library_name = "liblexy_file" + env["LIBSUFFIX"]
    library = lexy_env.StaticLibrary(target=os.path.join(source_path, library_name), source=sources)
    Default(library)

    include_dir = lexy_env.Dir(include_path)
    source_dir = lexy_env.Dir(source_path)
    env.Append(CPPPATH=[include_dir])
    if env.get("is_msvc", False):
        env.Append(CXXFLAGS=["/external:I", include_dir, "/external:W0"])
    else:
        env.Append(CXXFLAGS=["-isystem", include_dir])
    env.Append(CXXFLAGS=[""])
    env.Append(LIBPATH=[source_dir])
    env.Prepend(LIBS=[library_name])

def build_dryad(env):
    include_path = "dryad/include"
    include_dir = env.Dir(include_path)
    env.dryad = {}
    env.dryad["INCPATH"] = [include_dir]
    env.Append(CPPPATH=env.dryad["INCPATH"])
    if env.get("is_msvc", False):
        env.Append(CXXFLAGS=["/external:I", include_dir, "/external:W0"])
    else:
        env.Append(CXXFLAGS=["-isystem", include_dir])
    
    env.exposed_includes += env.dryad["INCPATH"]

def build_fmt(env):
    fmt_env = env.Clone()

    # Require C++20
    if fmt_env.get("is_msvc", False):
        fmt_env.Append(CXXFLAGS=["/std:c++20"])

        fmt_env.Append(CXXFLAGS=["/WX", "/W3", "/D", "_CRT_SECURE_NO_WARNINGS"])
    else:
        fmt_env.Append(CXXFLAGS=["-std=c++20"])

        fmt_env.Append(CXXFLAGS=[
            "-Werror", "-Wall", "-Wextra", "-pedantic", "-Wconversion", "-Wundef"
        ])
        if fmt_env["CXX"] == "clang++":
            fmt_env.Append(CXXFLAGS=[
                "-Wweak-vtables", "-Wshadow",
                "-Wno-gnu-zero-variadic-macro-arguments"
            ])
        else:
            fmt_env.Append(CXXFLAGS=[
                "-Wsign-conversion", "-Wold-style-cast",
                "-Wundef", "-Wredundant-decls", "-Wwrite-strings",
                "-Wpointer-arith", "-Wcast-qual", "-Wformat=2",
                "-Wmissing-include-dirs", "-Wcast-align", "-Wctor-dtor-privacy",
                "-Wdisabled-optimization", "-Winvalid-pch", "-Woverloaded-virtual",
                "-Wconversion", "-Wundef", "-Wno-ctor-dtor-privacy", "-Wno-format-nonliteral",
                "-Wno-dangling-else", "-Wno-unused-local-typedefs", "-Wdouble-promotion",
                "-Wtrampolines", "-Wzero-as-null-pointer-constant", "-Wuseless-cast",
                "-Wvector-operation-performance", "-Wsized-deallocation", "-Wshadow",
                "-Wshift-overflow=2", "-Wnull-dereference", "-Wduplicated-cond"
            ])

    include_path = "fmt/include"
    source_path = "fmt/src"
    paths = [include_path, source_path]
    fmt_env.Append(CPPPATH=[[fmt_env.Dir(p) for p in paths]])
    sources = env.GlobRecursive("*.cc", paths, "fmt.cc")
    env.lexy_sources = sources

    library_name = "libfmt" + env["LIBSUFFIX"]
    library = fmt_env.StaticLibrary(target=os.path.join(source_path, library_name), source=sources)
    Default(library)

    include_dir = fmt_env.Dir(include_path)
    source_dir = fmt_env.Dir(source_path)

    env.fmt = {}
    env.fmt["INCPATH"] = [include_dir]

    env.Append(CPPPATH=env.fmt["INCPATH"])
    if env.get("is_msvc", False):
        env.Append(CXXFLAGS=["/external:I", include_dir, "/external:W0"])
    else:
        env.Append(CXXFLAGS=["-isystem", include_dir])
    env.Append(CXXFLAGS=[""])
    env.Append(LIBPATH=[fmt_env.Dir(source_path)])
    env.Prepend(LIBS=[library_name])
    
    env.exposed_includes += env.fmt["INCPATH"]

def build_range_v3(env):
    include_path = "range-v3/include"
    sources = env.GlobRecursive("*.cpp", [include_path])
    env.range_v3_sources = sources

    include_dir = env.Dir(include_path)

    env.range_v3 = {}
    env.range_v3["INCPATH"] = [include_dir]

    env.Append(CPPPATH=env.range_v3["INCPATH"])
    if env.get("is_msvc", False):
        env.Append(CXXFLAGS=["/external:I", include_dir, "/external:W0"])
    else:
        env.Append(CXXFLAGS=["-isystem", include_dir])
    
    env.exposed_includes += env.range_v3["INCPATH"]

build_dryad(env)
build_fmt(env)
build_lexy(env)
build_range_v3(env)