/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2011-2020 OpenFOAM Foundation
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenFOAM 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 OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

Application
    Test-List

Description
    Simple tests and examples of use of List

See also
    Foam::List

\*---------------------------------------------------------------------------*/

#include <vector> //std::vector


#include "OSspecific.H"
#include "argList.H"
#include "wordReList.H"

#include "IOstreams.H"
#include "IStringStream.H"
#include "scalar.H"
#include "vector.H"
#include "ListOps.H"

using namespace Foam;

namespace ListTestDetail
{

template<class InputIt>
static void linearIncrement(InputIt first, InputIt last)
{

    int i = 1;
    for (; first != last; first++)
    {
        *first += 1;
        i++;
    }

}


template<class T>
static bool isEqual(const std::vector<T>& vStd, const List<T>& vOf)
{
    if (vStd.size() != static_cast<size_t>(vOf.size())) 
    {
        return false;
    }

    for (size_t i = 0; i < vStd.size(); ++i)
    {
        if (vStd[i] != vOf[i])
        {
            return false;
        }
    }
    return true;
}

} //namespace ListTestDetail

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
//  Main program:

int main(int argc, char *argv[])
{
    argList::noParallel();
    argList::addOption("reList", "reList");
    argList::addOption("wordList", "wordList");
    argList::addOption("stringList", "stringList");
    argList::addOption("float", "xx");
    argList::addBoolOption("flag");

    #include "setRootCase.H"

    List<vector> list1(IStringStream("1 ((0 1 2))")());
    Info<< "list1: " << list1 << endl;

    List<vector> list2
    {
        vector(0, 1, 2),
        vector(3, 4, 5),
        vector(6, 7, 8)
    };
    Info<< "list2: " << list2 << endl;

    list1.append(list2);
    Info<< "list1.append(list2): " << list1 << endl;

    Info<< findIndex(list2, vector(3, 4, 5)) << endl;

    list2.setSize(10, vector(1, 2, 3));
    Info<< "list2: " << list2 << endl;

    List<vector> list3(move(list2));
    Info<< "Transferred move" << endl;
    Info<< "list2: " << list2 << nl
        << "list3: " << list3 << endl;

    List<vector> list4
    {
        vector(0, 1, 2),
        vector(3, 4, 5),
        vector(6, 7, 8)
    };
    Info<< "list4: " << list4 << endl;

    List<vector> list5
    {
        {5, 3, 1},
        {10, 2, 2},
        {8, 1, 0}
    };
    Info<< "list5: " << list5 << endl;
    list5 =
    {
        {8, 1, 0},
        {5, 3, 1},
        {10, 2, 2}

    };
    Info<< "list5: " << list5 << endl;

    list4.swap(list5);
    Info<< "Swapped via the swap() method" << endl;
    Info<< "list4: " << list4 << nl
        << "list5: " << list5 << endl;

    List<vector> list6(list4.begin(), list4.end());
    Info<< "list6: " << list6 << endl;

    // Subset
    const labelList map{0, 2};
    List<vector> subList3(list3, map);
    Info<< "Elements " << map << " out of " << list3
        << " => " << subList3 << endl;

    wordReList reLst;
    wordList wLst;
    stringList sLst;


    scalar xxx(-1);

    if (args.optionFound("flag"))
    {
        Info<<"-flag:" << args["flag"] << endl;
    }

    if (args.optionReadIfPresent<scalar>("float", xxx))
    {
        Info<<"read float " << xxx << endl;
    }

    if (args.optionFound("reList"))
    {
        reLst = args.optionReadList<wordRe>("reList");
    }

    if (args.optionFound("wordList"))
    {
        wLst = args.optionReadList<word>("wordList");
    }

    if (args.optionFound("stringList"))
    {
        sLst = args.optionReadList<string>("stringList");
    }

    Info<< nl
        << "-reList: " << reLst << nl
        << "-wordList: " << wLst << nl
        << "-stringList: " << sLst << endl;





    ///Iterator tests

    std::vector<int> vStd = {1,2,3,4};
    List<int> vOf(4, int());
    std::copy(vStd.begin(), vStd.end(), vOf.begin());

    if (!ListTestDetail::isEqual(vStd, vOf))
    {
        Info << "std::copy fails for Foam::List" << endl;
    }    

    //non-constant forward iterators
    ListTestDetail::linearIncrement(vStd.begin(), vStd.end());
    ListTestDetail::linearIncrement(vOf.begin(), vOf.end());

    if (!ListTestDetail::isEqual(vStd, vOf))
    {
        Info << "Non const forward iterators not working for Foam::List." << endl;
    }    

    //non-constant reverse iterators
    ListTestDetail::linearIncrement(vStd.rbegin(), vStd.rend());
    ListTestDetail::linearIncrement(vOf.rbegin(), vOf.rend());

    if (!ListTestDetail::isEqual(vStd, vOf))
    {
        Info << "Non const reverse iterators not working for Foam::List." << endl;
    }  

    //constant forward iterators
    Info << "std::vector: ";
    for (auto it = vStd.cbegin(); it != vStd.cend(); it++)
    {
        Info << *it << " ";
    }
    Info << endl;

    Info << "Foam::List: ";
    for (auto it = vOf.cbegin(); it != vOf.cend(); it++)
    {
        Info << *it << " ";
    }
    Info << endl;


    //constant revese iterators
    Info << "std::vector (reverse): ";
    for (auto it = vStd.crbegin(); it != vStd.crend(); it++)
    {
        Info << *it << " ";
    }
    Info << endl;

    Info << "Foam::List (reverse): ";
    for (auto it = vOf.crbegin(); it != vOf.crend(); it++)
    {
        Info << *it << " ";
    }
    Info << endl;



    return 0;
}

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