/*
    Copyright 2005-2014 Intel Corporation.  All Rights Reserved.

    This file is part of Threading Building Blocks. Threading Building Blocks is free software;
    you can redistribute it and/or modify it under the terms of the GNU General Public License
    version 2  as  published  by  the  Free Software Foundation.  Threading Building Blocks is
    distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
    implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    See  the GNU General Public License for more details.   You should have received a copy of
    the  GNU General Public License along with Threading Building Blocks; if not, write to the
    Free Software Foundation, Inc.,  51 Franklin St,  Fifth Floor,  Boston,  MA 02110-1301 USA

    As a special exception,  you may use this file  as part of a free software library without
    restriction.  Specifically,  if other files instantiate templates  or use macros or inline
    functions from this file, or you compile this file and link it with other files to produce
    an executable,  this file does not by itself cause the resulting executable to be covered
    by the GNU General Public License. This exception does not however invalidate any other
    reasons why the executable file might be covered by the GNU General Public License.
*/

#define _VARIADIC_MAX 10   // Visual Studio 2012
#include "harness.h"
#include "tbb/atomic.h"
#include "harness_checktype.h"

#include "tbb/flow_graph.h"
#include <cstdio>
#include <stdexcept>
#include <vector>

#if __TBB_GCC_STRICT_ALIASING_BROKEN
    #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

// given a tuple, return the type of the element that has the maximum alignment requirement.
// Given a tuple and that type, return the number of elements of the object with the max
// alignment requirement that is at least as big as the largest object in the tuple.

using tbb::flow::tuple_element;
using tbb::flow::tuple_size;
using tbb::flow::cast_to;
using tbb::flow::is_a;

typedef int *int_ptr;
typedef char odd_array_type[15];
typedef char odder_array[17];
typedef check_type<int> counted_array_type[12];
typedef std::vector<double> d_vector;
typedef std::vector<int> i_vector;
typedef i_vector i_vector_array[2];
typedef tbb::flow::tagged_msg<size_t, int, char, double, odd_array_type, odder_array, d_vector, check_type<int>, counted_array_type, i_vector_array> tagged_msg_type;

// test base of tagged_msg
void TestWrapper() {
    tbb::flow::interface7::internal::Wrapper<int> wi(42);
    const tbb::flow::interface7::internal::Wrapper<int> wic(23);

    REMARK("Value of wic is %d\n", wic.value());

    // pointer-type creation
    int point_to_me = 23;
    tbb::flow::interface7::internal::Wrapper<int_ptr> wip(&point_to_me);
    ASSERT(*(wip.value()) == 23, "Error in wip value");

    odd_array_type ww;
    for(int ii = 0; ii < 15; ++ii) { ww[ii] = char('0' + ii); } ww[14] = 0;

    tbb::flow::interface7::internal::Wrapper<odd_array_type> ci(ww);
    ASSERT(!strncmp(ci.value(), ww, 14), "odd_array_type ci not properly-constructed" );

    tbb::flow::interface7::internal::Wrapper<odd_array_type> ci2(ci);

    ASSERT(!strncmp(ci2.value(), ww, 14), "odd_array_type ci2 not properly-constructed" );

    d_vector di;
    di.clear();
    di.push_back(2.0);
    tbb::flow::interface7::internal::Wrapper<d_vector> dvec(di);
    ASSERT(dvec.value()[0] == 2.0, "incorrect value in vector");

    // test array of non-PODs.
    i_vector_array oia;
    oia[0].clear();
    oia[1].clear();
    oia[0].push_back(3);
    oia[1].push_back(2);
    tbb::flow::interface7::internal::Wrapper<i_vector_array> ia(oia);
    ASSERT((ia.value()[1])[0] == 2, "integer vector array element[1] misbehaved");
    ASSERT((ia.value()[0])[0] == 3, "integer vector array element[0] misbehaved");
    tbb::flow::interface7::internal::Wrapper<i_vector_array> iac(ia);
    ASSERT((iac.value()[1])[0] == 2, "integer vector array element[1] misbehaved");
    ASSERT((iac.value()[0])[0] == 3, "integer vector array element[0] misbehaved");

    // counted_array
    counted_array_type cat_orig;
    for(int i = 0; i < 12; ++i) cat_orig[i] = i + 1;
    tbb::flow::interface7::internal::Wrapper<counted_array_type> cat(cat_orig);
    for(int j = 0; j < 12; ++j)
        ASSERT(1 + j == cat.value()[j], "Error in cat array");

    int i = wi.value();
    ASSERT(i == 42, "Assignment to i failed");
    ASSERT(wi.value() == 42, "Assignment to wi failed");
    double d = wi.value();
    ASSERT(d == 42, "Implicit cast in assign to double failed");
    int_ptr ip = wip.value();
    ASSERT(ip == &(point_to_me), "Error in assignment of pointer");
}

void RunTests() {
    tagged_msg_type def;
    tagged_msg_type i(1,3);
    check_type<int>::check_type_counter = 0;
    int z;
    #if TBB_USE_EXCEPTIONS
    try {
        z = cast_to<int>(def); // disallowed (non-array returning int)
        ASSERT(false, "should not allow cast to int of non-array");
    }
    catch(...) {
        REMARK("cast of non-array to int disallowed (okay)\n");
    }
    #endif
    z = cast_to<int>(i);
    ASSERT(is_a<int>(i), "wrong type for i ( == int)");
    ASSERT(!(is_a<double>(i)), "Wrong type for i ( != double)");
    z = 5;
    z = cast_to<int>(i);

    const int &ref_i(cast_to<int>(i));
    ASSERT(ref_i == 3, "ref_i got wrong value");
    tagged_msg_type j(2,4);
    i = j;
    ASSERT(ref_i == 4, "assign to i did not affect ref_i");

    ASSERT( z == 3, "Error retrieving value from i");
    
    //updating and retrieving tags
    ASSERT(j.tag() == 2, "Error retrieving tag for j");
    j.set_tag(10);
    ASSERT(j.tag() == 10, "Error updating tag for j");

    tbb::flow::tagged_msg<char, int, char, double> k('a', 4);
    k.set_tag('b');
    ASSERT(k.tag() == 'b', "Error updating char tag");

    tagged_msg_type double_tagged_msg(3, 8.0);  
    ASSERT(is_a<double>(double_tagged_msg), "Wrong type for double_tagged_msg (== double)");
    ASSERT(!is_a<char>(double_tagged_msg), "Wrong type for double_tagged_msg (!= char)");
    ASSERT(!is_a<int>(double_tagged_msg), "Wrong type for double_tagged_msg (!= int)");
    tagged_msg_type copytype(double_tagged_msg);
    ASSERT(is_a<double>(copytype), "Wrong type for double_tagged_msg (== double)");
    ASSERT(!is_a<char>(copytype), "Wrong type for double_tagged_msg (!= char)");
    ASSERT(!is_a<int>(copytype), "Wrong type for double_tagged_msg (!= int)");
    tagged_msg_type default_tagged_msg;   
    ASSERT(!(is_a<double>(default_tagged_msg)), "wrong type for default ( != double)");
    ASSERT(!(is_a<int>(default_tagged_msg)), "wrong type for default ( != int)");
    ASSERT(!(is_a<bool>(default_tagged_msg)), "wrong type for default ( != bool)");
    check_type<int> c;
    ASSERT(check_type<int>::check_type_counter == 1, "Incorrect number of check_type<int>s created");
    tagged_msg_type cnt_type(4, c);
    ASSERT(check_type<int>::check_type_counter == 2, "Incorrect number of check_type<int>s created");
    ASSERT(is_a<check_type<int> >(cnt_type), "Incorrect type for cnt_type");
    cnt_type = default_tagged_msg;
    ASSERT(check_type<int>::check_type_counter == 1, "Incorrect number of check_type<int>s after reassignment");
    ASSERT(cnt_type.is_default_constructed(), "Assigned check_type<int>s is not default-constructed");
    // having problem with init on gcc 3.4.6 (fxeolin16)  constructor for elements of array not called
    // for this version.
    // counted_array_type counted_array;
    check_type<int> counted_array[12];  // this is okay
    ASSERT(check_type<int>::check_type_counter == 13, "Incorrect number of check_type<int>s after counted_array construction");
    tagged_msg_type counted_array_tagged_msg(5, counted_array);
    // the is_a<>() should return exact type matches.
    ASSERT(!is_a<check_type<int> *>(counted_array_tagged_msg), "Test of is_a for counted_array_tagged_msg fails");
    #if TBB_USE_EXCEPTIONS
    try {
        int *iip = cast_to<int *>(counted_array_tagged_msg);
        ASSERT(false, "did not throw on invalid cast");
        *iip = 2;  // avoids "ipp set but not used" warning
    }
    catch(std::runtime_error &re) {
        REMARK("attempt to cast to invalid type caught %s\n", re.what());
    }
    ASSERT(is_a<counted_array_type>(counted_array_tagged_msg), "testing");
    const check_type<int> *ctip = cast_to<counted_array_type>(counted_array_tagged_msg);

    ASSERT((int)(*ctip) == 0, "ctip incorrect");

    ASSERT(check_type<int>::check_type_counter == 25, "Incorrect number of check_type<int>s after counted_array_tagged_msg construction");
    counted_array_tagged_msg = default_tagged_msg;
    ASSERT(check_type<int>::check_type_counter == 13, "Incorrect number of check_type<int>s after counted_array_tagged_msg destruction");
    ASSERT(counted_array_tagged_msg.is_default_constructed(), "Assigned counted_array_type is not default-constructed");

    default_tagged_msg = double_tagged_msg;
    const double my_dval = cast_to<double>(default_tagged_msg);
    ASSERT(my_dval == 8.0, "did not retrieve correct value from assigned default_tagged_msg");

    {
        odd_array_type my_b;
        for(size_t ii=0; ii < 14;++ii) {
            my_b[ii] = (char)('0' + ii);
        }
        my_b[14] = 0;
        {
            tagged_msg_type odd_array_tagged_msg(6, my_b);
            const char *my_copy = cast_to<odd_array_type>(odd_array_tagged_msg);
            ASSERT(!strncmp(my_b, my_copy, 14), "copied char array not correct value");
            default_tagged_msg = odd_array_tagged_msg;
            try {
                const char *my_copy2 = cast_to<odd_array_type>(default_tagged_msg);
                ASSERT(!strncmp(my_b, my_copy2, 14), "char array from default tagged_msg assign not correct value");
            }
            catch(...) {
                ASSERT(false, "Bad cast");
            }
        }
    }

    ASSERT(!is_a<double>(i), "bad type for i");
    try {
        double y = cast_to<double>(i);
        // use '&' to force eval of RHS (fixes "initialized but not referenced" vs2012 warnings)
        ASSERT(false & (0 != y), "Error: cast to type in tuple did not get exception");
    }
    catch(std::runtime_error &bc) {
        ASSERT(0 == strcmp(bc.what(), "Illegal tagged_msg cast"), "Incorrect std:runtime_error");
    }
    catch(...) {
        ASSERT(false & cast_to<int>(i), "Error: improper exception thrown");
    }

    try {
        int *ip = cast_to<int *>(i);
        ASSERT(false & (NULL!=ip), "Error: non-array cast to pointer type.");
    }
    catch(std::runtime_error &bc) {
        ASSERT(0 == strcmp(bc.what(), "Illegal tagged_msg cast"), "Incorrect std:runtime_error");
    }
    catch(...) {
        ASSERT(false, "did not get runtime_error exception in casting non-array to pointer");
    }

    try {
        bool b = cast_to<bool>(i);
        ASSERT(false & b, "Error: cast against type did not get exception");
    }
    catch(std::runtime_error &bc) {
        ASSERT(0 == strcmp(bc.what(), "Illegal tagged_msg cast"), "Incorrect std:runtime_error");
    }
    catch(...) {
        ASSERT(false, "did not get runtime_error exception casting to disparate types");
    }
    #endif //TBB_USE_EXCEPTIONS
}

int TestMain() {
    TestWrapper();
    ASSERT(check_type<int>::check_type_counter == 0, "After TestWrapper return not all check_type<int>s were destroyed");
    RunTests();
    ASSERT(check_type<int>::check_type_counter == 0, "After RunTests return not all check_type<int>s were destroyed");
    return Harness::Done;
}
