import common ;
using doxygen ;
import doxygen ;
import feature ;
import os ;
import path ;
using testing ;


# Calculate install path from PREFIX environment variable or use default
local prefix-from-environ = [ os.environ PREFIX ] ;
if ( $(prefix-from-environ) ) {
    if ( [ path.is-rooted $(prefix-from-environ) ] ) {
        path-constant PREFIX : $(prefix-from-environ) ;
    } else {
        path-constant PREFIX : $(TOP)/$(prefix-from-environ) ;
    }
} else {
    path-constant PREFIX : $(TOP)/../dist ;
}

TARGET_INPUTS =
        $(TOP)/../Boost//boost-date_time-dll
        $(TOP)/../Boost//boost-filesystem-dll
        $(TOP)/../Boost//boost-regex-dll
        $(TOP)/../Boost//boost-system-dll
        $(TOP)/../Boost//boost-thread-dll
        $(TOP)/../fost-base/Cpp/fost-core//fost-core
    ;
TARGET_REQUIREMENTS =
        <target-os>darwin:<source>$(TOP)/../fost-base/External//openssl
        <target-os>iphone:<source>$(TOP)/../OpenSSL//crypto
        <target-os>iphone:<source>$(TOP)/../OpenSSL//ssl
        <target-os>linux:<source>$(TOP)/../fost-base/External//openssl
        <target-os>windows:<source>$(TOP)/../fost-base/External//ole
        <target-os>windows:<source>$(TOP)/../OpenSSL//libeay32-dll
        <target-os>windows:<source>$(TOP)/../OpenSSL//ssleay32-dll
        <toolset>gcc:<cxxflags>-fdiagnostics-show-option
        <toolset>gcc:<cxxflags>-fno-strict-aliasing
    ;

rule fost-project ( name : requirements * ) {
    project
        :
            requirements

            $(requirements)

            <include>Cpp/include
            <include>../fost-base/Cpp/include
            <include>$(BOOST_HEADERS)
            <target-os>iphone:<include>../OpenSSL/install/include/
            <target-os>windows:<include>../OpenSSL/install/include/

            <define>BOOST_VERSION_MAJOR=$(BOOST_VERSION_MAJOR)
            <define>BOOST_VERSION_MINOR=$(BOOST_VERSION_MINOR)

            <threading>multi
            <runtime-link>shared

            <variant>debug:<define>DEBUG
            <variant>debug:<define>_DEBUG
            <variant>debug-mfc:<define>DEBUG
            <variant>debug-mfc:<define>_DEBUG
            <variant>release:<define>NDEBUG
            <variant>release-mfc:<define>NDEBUG

            <target-os>darwin:<define>FOST_OS_OSX

            <target-os>linux:<define>FOST_OS_LINUX

            <target-os>windows:<define>FOST_OS_WINDOWS
            <target-os>windows:<define>UNICODE
            <target-os>windows:<define>_UNICODE

            <target-os>windows:<exception-handling>on
            <target-os>windows:<asynch-exceptions>on
            <target-os>windows:<extern-c-nothrow>off
        :
        :
            build-dir $(BUILD_DIRECTORY)
        ;
}

rule fost-install-to-directory ( lib-dir : exe-dir : sources + ) {
    for local source in $(sources) {
        install $(source)-lib
            :
                $(source)
            :
                <location>$(lib-dir)
                <dll-path>$(lib-dir)
                <target-os>linux:<install-type>LIB
                <target-os>darwin:<install-type>LIB
                <target-os>windows:<install-type>XXX
            ;

        install $(source)-loc
            :
                $(source)
            :
                <location>$(exe-dir)
                <dll-path>$(lib-dir)
                <install-type>EXE
                <target-os>windows:<install-type>LIB
            ;
    }
}
rule fost-install-loc ( loc : sources + ) {
    fost-install-to-directory $(loc)/lib : $(loc)/bin : $(sources) ;
}
rule fost-install ( sources + ) {
    fost-install-loc $(PREFIX) : $(sources) ;
}
rule fost-py-install ( pyd : location ) {
    install $(location)
        : $(pyd)
        : <location>$(PREFIX)/lib/python/site-packages/$(location)
    ;
}


rule fost-smoke-test ( name : libs * : files * ) {
    if ( $(files) ) {
        local unit-test-name = $(name) "-unit-test" ;
        unit-test $(unit-test-name:J)
            :
                $(TARGET_INPUTS)
                $(TOP)/../fost-base/Cpp/fost-cli//fost-cli
                $(TOP)/../fost-base/Cpp/fost-test
                $(TOP)/../fost-base/Cpp/fost-test/boost-build-unit-test.cpp
                $(libs)
                $(files)
            :
                $(TARGET_REQUIREMENTS)
            ;
    }
}
rule run-py-test ( test-name : sources + ) {
    import testing ;
    testing.make-test run-pyd : $(sources) : : $(test-name) ;
}

rule fost-tag-output ( name : type ? : properties * ) {
    if $(type) in OBJ {
        # Don't do anything for OBJ files
    } else if $(type) in EXE {
        if [ $(properties).get <variant> ] in debug debug-mfc {
            if [ $(properties).get <target-os> ] in windows {
                local n = $(name) "-gd.exe" ;
                return $(n:J) ;
            } else {
                local n = $(name) "-d" ;
                return $(n:J) ;
            }
        }
    } else if $(type) in STATIC_LIB && [ $(properties).get <target-os> ] in iphone {
        if [ $(properties).get <architecture> ] in arm {
            return $(name)-arm.a ;
        } else {
            return $(name)-x86.a ;
        }
    } else if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB {
        if [ $(properties).get <variant> ] in debug-mfc {
            if $(type) in SHARED_LIB {
                return $(name)-gd.dll ;
            } else if $(type) in IMPORT_LIB {
                return $(name)-gd.lib ;
            } else {
                echo "Unknown type for debug-mfc build" $(type) $(name) ;
            }
        } else {
            # For more options here take a look at the rule "tag" in Boost's Jamroot
            return [ common.format-name <base> <runtime> : $(name) : $(type) : $(properties) ] ;
        }
    } else {
        # We don't yet know what to do about these target types
        echo $(name) $(type) $(properties) ;
    }
}

rule fost-lib ( name : sources + : requirements * : install-loc ? ) {
    lib $(name)
        :
            $(TARGET_INPUTS)
            $(sources)
        :
            $(requirements)
            $(TARGET_REQUIREMENTS)
            <tag>@fost-tag-output
        ;
    if $(install-loc) {
        fost-install-to-directory $(install-loc) : $(install-loc) : $(name) ;
    } else {
        fost-install $(name) ;
    }
}

rule fost-exe ( name : sources + : requirements * ) {
    exe $(name)
        :
            $(TARGET_INPUTS)
            $(TOP)/../fost-base/Cpp/fost-cli
            $(sources)
        :
            $(requirements)
            $(TARGET_REQUIREMENTS)
            <tag>@fost-tag-output
        ;
    fost-install $(name) ;
}

rule fost-lib-autotest ( name : location : libs * : requirements * : install-loc ? ) {
    fost-lib $(name)
        : $(libs) [ path.glob $(TOP)/$(location) : *.cpp : *-tests.cpp ]
        : $(requirements)
        : $(install-loc)
        ;
    local smoke-test-name = $(name) "-unit-tests" ;
    fost-smoke-test $(smoke-test-name:J)
        : $(libs) $(name)
        : [ path.glob $(TOP)/$(location) : *-tests.cpp ]
        ;
}
rule fost-integration-test ( name : location : libs * : requirements * : install-loc ? ) {
    fost-smoke-test $(name)
        : $(libs)
        : [ path.glob $(TOP)/$(location) : *.cpp ]
        ;
}


rule fost-mkdir
{
    fost-mkdir-i $(<) ;
}
actions fost-mkdir-i
{
    mkdir -p $(<)
}


rule fost-doxygen ( name : path : sources * ) {
    path-constant DOC_PATH : $(PREFIX)/$(path) ;
    alias $(DOC_PATH) ;
    fost-mkdir-i $(DOC_PATH) ;
    #make $(DOC_PATH) : : @fost-mkdir ;
    doxygen name : $(sources) :
            -<threading>multi # Works around a bug in boost.build
            # Boost.Build in 1.42.0 requires this to be relative
            #<location>../../../dist/usr/share/fost/ # Relative to Docs in the build folder
            <dependency>$(DOC_PATH)

            <doxygen:param>SEARCH_INCLUDES=YES
            <doxygen:param>INCLUDE_PATH=Cpp/include
            <doxygen:param>SHOW_INCLUDE_FILES=YES
            <doxygen:param>OUTPUT_DIRECTORY=$(DOC_PATH)
        ;
}