/******************************************************************************

    Struct Converter functions

    Functions to make converting an instance to a similar but not equal type
    easier.

    Copyright:
        Copyright (c) 2009-2016 dunnhumby Germany GmbH.
        All rights reserved.

    License:
        Boost Software License Version 1.0. See LICENSE_BOOST.txt for details.
        Alternatively, this file may be distributed under the terms of the Tango
        3-Clause BSD License (see LICENSE_BSD.txt for details).

 ******************************************************************************/

module ocean.core.StructConverter;

import ocean.meta.types.Qualifiers;
import ocean.meta.codegen.Identifier;
import ocean.meta.traits.Basic;
import ocean.meta.types.Arrays : StripAllArrays;
import ocean.core.TypeConvert : toDg;

version (unittest) import ocean.core.Test;

/***************************************************************************

    Copies members of the same name from <From> to <To>.

    Given a variable in <To> called 'example_var', if a static convert function
    in <To> exists with the name 'convert_example_var', then this function will
    be called and no automatic conversion will happen for that variable. The
    function must have one of the following signatures:
    ---
    void function ( ref <From>, ref <To>, void[] delegate ( size_t ) )
    void function ( ref <From>, ref <To> )
    ---
    The delegate passed to the first version can be used to allocate temporary
    buffers that the convert function might need in order to do its converting.

    If no convert function exists and the types differ, various things happen:

    * For structs it calls this function again
    * For dynamic arrays, a temporary array of the same length is created and
      this function is called for every element of the array
    * For static arrays the same happens, just without a temporary allocation

    If the types are the same a simple assignment will be done. The types have
    to match exactly, implicit conversions are not supported.

    It is an error if a variable in <To> doesn't exist in <From> and no convert
    function for it exists,

    Note: Dynamic arrays of the same type will actually reference the same
          memory where as arrays of similar types that were converted use memory
          provided by the requestBuffer delegate.

    Params:
        From          = type we're copying from
        To            = type we're copying to
        from          = instance we're copying from
        to            = instance we're copying to
        requestBuffer = delegate to request temporary buffers used during
                        conversion.

***************************************************************************/

public void structConvert ( From, To ) ( ref From from, out To to,
    void[] delegate ( size_t ) requestBuffer
        = ( size_t n ) { return new void[n]; } )
{
    static assert (is(From == struct) && is (To == struct),
            "structConvert works only on structs, not on " ~
            From.stringof ~ " / " ~ To.stringof);

    static if (is(From == To))
    {
        to = from;
    }
    else
    {
        foreach ( to_index, ref to_member; to.tupleof )
        {
            enum fieldName = identifier!(to.tupleof[to_index]);
            enum convFuncName = "convert_" ~ fieldName;

            static if (hasConvertFunction!(From, convFuncName, To)())
            {
                callBestOverload!(From, To, convFuncName)(from, to, requestBuffer);
            }
            else static if (structHasMember!(fieldName, From)())
            {
                auto from_field = getField!(fieldName)(from);
                auto to_field = &to.tupleof[to_index];

                copyField(from_field, to_field, requestBuffer);
            }
            else
            {
                static assert ( false, "Unhandled field: " ~
                            fieldName ~ " of type " ~
                            typeof(to_member).stringof);
            }
        }
    }
}

/*******************************************************************************

    Helper function for structConvert().

    Copies a field to another field, doing a conversion if required and
    possible.

    Params:
        From = type of field we copy/convert from
        To   = type of field we copy/convert to
        from_field = pointer to the field we want to copy/convert from
        to_field   = pointer to the field we want to copy/convert to
        requestBuffer = delegate to request temporary memory for doing
                        conversions

*******************************************************************************/

private void copyField ( From, To ) ( From* from_field, To* to_field,
                                      void[] delegate ( size_t ) requestBuffer )
{
    static if ( is ( typeof(*to_field) : typeof(*from_field) ) )
    {
        static if ( isArrayType!(typeof((*to_field))) == ArrayKind.Static )
        {
            (*to_field)[] = (*from_field)[];
        }
        else
        {
            *to_field = *from_field;
        }
    }
    else static if ( is ( typeof((*to_field)) == struct ) &&
                     is ( typeof(*from_field) == struct ) )
    {
        alias structConvert!(typeof(*from_field), typeof((*to_field))) copyMember;

        copyMember(*from_field, *to_field,
                   requestBuffer);
    }
    else static if (isArrayType!(typeof((*to_field))) == ArrayKind.Static &&
                    isArrayType!(typeof(*from_field)) == ArrayKind.Static)
    {
        alias StripAllArrays!(typeof(*to_field))   ToBaseType;
        alias StripAllArrays!(typeof(*from_field)) FromBaseType;

        static if ( is(ToBaseType == struct) &&
                    is(FromBaseType == struct) )
        {
            foreach ( i, ref el; *to_field )
            {
                structConvert!(FromBaseType, ToBaseType)((*from_field)[i],
                                                       el, requestBuffer);
            }
        }
        else
        {
            static assert (1==0, "Unsupported auto-struct-conversion " ~
                FromBaseType.stringof ~ " -> " ~ ToBaseType.stringof ~
                ". Please provide the convert function " ~ To.stringof ~
                 "." ~ convertToFunctionName(FieldName!(to_index, To)));
        }
    }
    else static if (isArrayType!(typeof((*to_field))) == ArrayKind.Dynamic &&
                    isArrayType!(typeof(*from_field)) == ArrayKind.Dynamic)
    {
        alias StripAllArrays!(typeof(*to_field))   ToBaseType;
        alias StripAllArrays!(typeof(*from_field)) FromBaseType;

        static if ( is(ToBaseType == struct) &&
                    is(FromBaseType == struct) )
        {
            if ( from_field.length > 0 )
            {
                auto buf = requestBuffer(from_field.length * ToBaseType.sizeof);

                *to_field = (cast(ToBaseType*)buf)[0 .. from_field.length];

                foreach ( i, ref el; *to_field )
                {
                    structConvert!(FromBaseType, ToBaseType)((*from_field)[i],
                                                          el, requestBuffer);
                }
            }
            else
            {
                *to_field = null;
            }
        }
        else
        {
            static assert (false, "Unsupported auto-struct-conversion " ~
                FromBaseType.stringof ~ " -> " ~ ToBaseType.stringof ~
                ". Please provide the convert function " ~ To.stringof ~
                 "." ~ convertToFunctionName(FieldName!(to_index, To)));
        }
    }
    else
    {
        // Workaround for error-swallowing DMD1 bug
        /+
            module main;

            size_t foo ( bool bar ) ( int )
            {
            }

            unittest
            {
                    foo!(true) ();
            }

            Outputs:
                main.d(10): Error: template main.foo(bool bar) does not match any function template declaration
                main.d(10): Error: template main.foo(bool bar) cannot deduce template function from argument types !(true)()

            Fixing the error in foo (by adding `return 0;`) changes the output to

            main.d(10): Error: function main.foo!(true).foo (int _param_0) does not match parameter types ()
            main.d(10): Error: expected 1 function arguments, not 0
        +/

        pragma(msg, "Unhandled field: " ~
                    FieldName!(to_index, To) ~ " of types " ~ To.stringof ~ "." ~
                        typeof((*to_field)).stringof ~ " " ~ From.stringof ~ "." ~
                        typeof(*from_field).stringof);

        static assert ( false, "Unhandled field: " ~
                        FieldName!(to_index, To) ~ " of types " ~
                        typeof((*to_field)).stringof ~ " " ~
                        typeof(*from_field).stringof);
    }
}

/*******************************************************************************

    Checks whether struct S has a member (variable or method) of the given name

    Params:
        name = name to check for
        S    = struct to check

    Returns:
        true if S has queried member, else false

*******************************************************************************/

private bool structHasMember ( string name, S ) ( )
{
    mixin(`
        static if (is(typeof(S.` ~ name ~`)))
        {
            return true;
        }
        else
        {
            return false;
        }`);
}

/*******************************************************************************

    Calls the function given in function_name in struct To.
    The function must have one of the following signatures:
    ---
    void delegate ( ref <From>, void[] delegate ( size_t ) )
    void delegate ( ref <From> )
    void delegate ( );
    ---

    Params:
        From = type of the struct that will be passed to the function
        To   = type of the struct that has to have that function
        function_name = name of the function that To must have
        from = struct instance that will be passed to the function
        to   = struct instance that should have said function declared
        requestBuffer = memory request method that the function can use (it
                        should not allocate memory itself)

*******************************************************************************/

private void callBestOverloadOld ( From, To, string function_name )
           ( ref From from, ref To to, void[] delegate ( size_t ) requestBuffer )
{
     mixin (`
        void delegate ( ref From, void[] delegate ( size_t ) ) longest_convert;
        void delegate ( ref From ) long_convert;
        void delegate ( ) convert;

        static if ( is ( typeof(longest_convert = &to.`~function_name~`)) )
        {
            longest_convert = &to.`~function_name~`;

            longest_convert(from, requestBuffer);
        }
        else static if ( is ( typeof(long_convert = &to.`~function_name~`)) )
        {
            long_convert = &to.`~function_name~`;

            long_convert(from);
        }
        else static if ( is ( typeof(convert = &to.`~function_name~`)) )
        {
            convert = &to.`~function_name~`;

            convert();
        }
        else
        {
            const convFuncTypeString = typeof(&to.`~function_name~`).stringof;
            static assert ( false,
              "Function ` ~
             To.stringof ~ `.` ~ function_name ~
             ` (" ~ convFuncTypeString ~ ") doesn't `
           ~ `have any of the accepted types `
           ~ `'void delegate ( ref "~From.stringof~", void[] delegate ( size_t ) )' or `
           ~ `'void delegate ( ref "~From.stringof~" )' or `
           ~ `'void delegate ( )'" );
        }`);

}

/*******************************************************************************

    Checks if a given type T is of the old convert function style

    Params:
        From = struct that we convert from
        T    = function/delegate type that is used
        t    = pointer to the function/delegate that is used

    Returns:
        true if the given function/delegate is of the old convert style

*******************************************************************************/

private bool isOldOverload ( From, string func_name, To ) ( )
{
    void delegate ( ref From, void[] delegate ( size_t ) ) longest_convert;
    void delegate ( ref From ) long_convert;
    void delegate ( ) convert;

    To to;

    mixin(`
    static if ( is ( typeof(longest_convert = &to.` ~ func_name ~ `) ))
    {
        return true;
    }
    else static if ( is ( typeof(long_convert = &to.` ~ func_name ~ `) ))
    {
        return true;
    }
    else static if ( is ( typeof(convert = &to.` ~ func_name ~ ` )  ))
    {
        return true;
    }
    else
    {
        return false;
    }`);
}

version (unittest)
{
    struct Test ( ubyte Ver )
    {
        void old ( ) {}

        static void should_fail1 ( ) {}
        void should_fail2 ( ref Test!(1) from, ref Test!(2) to ) {}
    }

    unittest
    {
        Test!(2) t;

        static assert(isOldOverload!(Test!(1), "old", Test!(2))());
        static assert(!isOldOverload!(Test!(1), "should_fail1", Test!(2))());
        static assert(!isOldOverload!(Test!(1), "should_fail2", Test!(2))());
    }
}

/*******************************************************************************

    Checks if a convert function of the given name exists for the given structs

    Params:
        From = struct that we convert from
        func_name = name of the function we're looking for
        To = struct we're converting to

    Returns:
        true if such a function is found

*******************************************************************************/

private bool hasConvertFunction ( From, string func_name, To ) ( )
{
    static if (is (typeof(isOldOverload!(From, func_name, To)())))
        if (isOldOverload!(From, func_name, To)())
            return true;

    void function ( ref From, ref To, void[] delegate ( size_t ) ) longest_convert;
    void function ( ref From, ref To ) long_convert;

    mixin(`
    static if ( is ( typeof(longest_convert = &To.` ~ func_name ~ `) ))
    {
        return true;
    }
    else static if ( is ( typeof(long_convert = &To.` ~ func_name ~ `) ))
    {
        return true;
    }
    else
    {
        return false;
    }`);
}

/*******************************************************************************

    Calls the function given in function_name in struct To.
    The function must have one of the following signatures:
    ---
    void function ( ref <From>, ref <To>, void[] delegate ( size_t ) )
    void function ( ref <From>, ref <To> )
    ---

    Params:
        From = type of the struct that will be passed to the function
        To   = type of the struct that has to have that function
        function_name = name of the function that To must have
        from = struct instance that will be passed to the function
        to   = struct instance that should have said function declared
        requestBuffer = memory request method that the function can use (it
                        should not allocate memory itself)

*******************************************************************************/

private void callBestOverload ( From, To, string function_name )
           ( ref From from, ref To to, void[] delegate ( size_t ) requestBuffer )
{
     mixin (`
        void function ( ref From, ref To, void[] delegate ( size_t ) ) longest_convert;
        void function ( ref From, ref To ) long_convert;

        static if (is (typeof(isOldOverload!(From, function_name, To)())))
            const is_old = isOldOverload!(From, function_name, To)();
        else
            const is_old = false;

        static if (is_old)
        {
            // None matched, try legacy signatures
            callBestOverloadOld!(From, To, function_name)(from, to, requestBuffer);
        }
        else static if ( is ( typeof(longest_convert = &To.`~function_name~`)) )
        {
            To.`~function_name~`(from, to, requestBuffer);
        }
        else static if ( is ( typeof(long_convert = &To.`~function_name~`)) )
        {
            To.`~function_name~`(from, to);
        }
        else
        {
            const convFuncTypeString = typeof(&to.`~function_name~`).stringof;
            static assert ( false,
              "Function ` ~
             To.stringof ~ `.` ~ function_name ~
             ` (" ~ convFuncTypeString ~ ") doesn't ` ~
             `have any of the accepted types ` ~
             `'void function ( ref "~From.stringof~", ref "~To.stringof~", void[] delegate ( size_t ) )' or ` ~
             `'void function ( ref "~From.stringof~", ref "~To.stringof~" )'");
        }`);
}

/*******************************************************************************

    aliases to the type of the member <name> in the struct <Struct>

    Params:
        name = name of the member you want the type of
        Struct = struct that <name> is member of

*******************************************************************************/

private template TypeOf ( string name, Struct )
{
    mixin(`alias typeof(Struct.`~name~`) TypeOf;`);
}

/*******************************************************************************

    Returns a pointer to the field <field_name> defined in the struct <Struct>

    Params:
        field_name = name of the field in the struct <Struct>
        Struct     = struct that is expected to have a member called
                     <field_name>

    Returns:
        pointer to the field <field_name> defined in the struct <Struct>

*******************************************************************************/

private TypeOf!(field_name, Struct)* getField ( string field_name, Struct )
                                              ( ref Struct s )
{
    mixin(`
        static if ( is ( typeof(Struct.`~field_name~`) ) )
        {
            return &(s.`~field_name~`);
        }
        else
        {
            return null;
        }`);
}

version (unittest)
{
    void[] testAlloc( size_t s )
    {
        return new void[s];
    }
}

// same struct
unittest
{
    struct A
    {
        int x;
    }

    A a1, a2;
    a1.x = 42;

    structConvert(a1, a2, toDg(&testAlloc));
    test ( a1.x == a2.x, "failure to copy same type instances" );
}

// same fields, different order
unittest
{
    struct A
    {
        int a;
        int b;
        short c;
    }

    struct B
    {
        short c;
        int a;
        int b;
    }

    auto a = A(1,2,3);
    B b;

    structConvert(a, b, toDg(&testAlloc));

    test ( a.a == b.a, "a != a" );
    test ( a.b == b.b, "b != b" );
    test ( a.c == b.c, "c != c" );
}

// no conversion method -> failure
unittest
{
    struct A
    {
        int x;
    }

    struct B
    {
        int x;
        int y;
    }

    A a; B b;

    static assert (!is(typeof(structConvert(a, b, toDg(&testAlloc)))));
}

// multiple conversions at once
unittest
{
    static struct A
    {
        int a;
        int b;
        int[][] i;
        int c;
        char[] the;

        struct C
        {
            int b;
        }

        C srt;
    }

    static struct B
    {
        int c;
        short b;
        int a;
        short d;
        char[] the;
        int[][] i;

        struct C
        {
            int b;
            int c;
            int ff;

            // verify different conversion signatures...
            static void convert_c ( ref A.C, ref C ) {}
            static void convert_ff ( ref A.C, ref C, void[] delegate ( size_t ) ) {}
        }

        C srt;

        static void convert_b ( ref A structa, ref B dst )
        {
            dst.b = cast(short) structa.b;
        }

        static void convert_d ( ref A structa, ref B dst )
        {
            dst.d = cast(short) structa.a;
        }
    }

    auto a = A(1,2, [[1,2], [45,234], [53],[3]],3, "THE TEH THE RTANEIARTEN".dup);
    B b_loaded;

    structConvert!(A, B)(a, b_loaded, toDg(&testAlloc));

    test ( b_loaded.a == a.a, "Conversion failure" );
    test ( b_loaded.b == a.b, "Conversion failure" );
    test ( b_loaded.c == a.c, "Conversion failure" );
    test ( b_loaded.d == a.a, "Conversion failure" );
    test ( b_loaded.the[] == a.the[], "Conversion failure" );
    test ( b_loaded.the.ptr == a.the.ptr, "Conversion failure" );
    test ( b_loaded.i.ptr == a.i.ptr, "Conversion failure" );
    test ( b_loaded.i[0][] == a.i[0][], "Nested array mismatch" );
    test ( b_loaded.i[1][] == a.i[1][], "Nested array mismatch" );
    test ( b_loaded.i[2][] == a.i[2][], "Nested array mismatch" );
    test ( b_loaded.i[3][] == a.i[3][], "Nested array mismatch" );
}

// multiple conversion overloads

version (unittest)
{
    // can't place those structs inside unit test block because of
    // forward reference issue

    struct A
    {
        int x;

        static void convert_x ( ref B src, ref A dst )
        {
            dst.x = cast(int) src.x;
        }
    }

    struct B
    {
        uint x;

        static void convert_x ( ref A src, ref B dst )
        {
            dst.x = cast(uint) src.x;
        }

        static void convert_x ( ref C src, ref B dst )
        {
            dst.x = cast(uint) src.x;
        }
    }

    struct C
    {
        double x;

        static void convert_x ( ref B src, ref C dst )
        {
            dst.x = src.x;
        }
    }
}

unittest
{
    A a; B b; C c;

    a.x = 42;
    structConvert(a, b, toDg(&testAlloc));
    test(b.x == 42);

    b.x = 43;
    structConvert(b, a, toDg(&testAlloc));
    test(a.x == 43);

    structConvert(b, c, toDg(&testAlloc));
    test(c.x == 43);

    c.x = 44;
    structConvert(c, b, toDg(&testAlloc));
    test(b.x == 44);
}