/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2017-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
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/>.

Description
    Test token construct assign etc.
\*---------------------------------------------------------------------------*/

#include "argList.H"
#include "IOobject.H"
#include "IOstreams.H"
#include "IFstream.H"
#include "cpuTime.H"
#include "labelList.H"
#include "scalarList.H"
#include "DynamicList.H"
#include "labelField.H"
#include "scalarField.H"
#include "SubField.H"
#include "SpanStream.H"
#include "formattingEntry.H"

using namespace Foam;

const char yesno[2] = { 'n', 'y' };

void printIntegralTest(const token& tok)
{
    Info<< "Test: " << tok.info() << nl
        << "  is  int32 = " << yesno[tok.is_int32()]
        << ", int64 = " << yesno[tok.is_int64()]
        << ", uint32 = " << yesno[tok.is_uint32()]
        << ", uint64 = " << yesno[tok.is_uint64()]
        << nl;
}


void printFloatTest(const token& tok)
{
    Info<< "Test: " << tok.info() << nl
        << "  is  float = " << yesno[tok.isFloat()]
        << ", double = " << yesno[tok.isDouble()]
        << ", number = " << yesno[tok.isNumber()]
        << nl;
}


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

int main(int argc, char *argv[])
{
    argList::noBanner();
    argList::noParallel();

    argList args(argc, argv, false, true);

    token tok1;
    Info<< "default construct: " << tok1.info() << endl;

    tok1 = label(100);
    Info<< "assign label: " << tok1.info() << endl;

    tok1 = int64_t(100);
    Info<< "assign int64: " << tok1.info() << endl;

    tok1 = int32_t(100);
    Info<< "assign int32: " << tok1.info() << endl;

    {
        tok1.int64Token(int64_t(INT32_MIN)-1);
        Info<< "set int64Token: " << tok1.info() << endl;

        printIntegralTest(tok1);
        printFloatTest(tok1);
    }

    tok1 = double(3.14159);
    Info<< "assign double: " << tok1.info() << endl;

    token tok2(tok1);
    Info<< "copy construct: " << tok2.info() << endl;

    tok1 = word("this-word");
    Info<< "assign word: " << tok1.info() << endl;

    token tok3(tok1);
    Info<< "copy construct: " << tok3.info() << endl;
    Info<< "orig: " << tok1.info() << endl;

    token tok4(std::move(tok1));
    Info<< "move construct: " << tok4.info() << endl;
    Info<< "orig: " << tok1.info() << endl;

    tok3 = tok4;
    Info<< "assign token: " << tok3.info() << endl;
    Info<< "orig: " << tok4.info() << endl;

    //
    // Compound
    //

    {
        // This version is good

        token ctok1(new token::Compound<labelList>(identity(10)));

        Info<< "compound from pointer: "
            << ctok1.info() << nl << ctok1 << endl;
    }

    {
        // This also works, but not actually using the autoPtr directly

        autoPtr<token::compound> ptr
        (
            new token::Compound<labelList>(identity(10, -9))
        );

        token ctok1(ptr.release());  // release() not get()!

        Info<< "compound from autoPtr: "
            << ctok1.info() << nl << ctok1 << endl;
    }

    {
        // Construct from pointer
        autoPtr<token::compound> ptr
        (
            token::compound::New("List<label>")
        );

        token ctok1(ptr.release());  // release() not get()!

        Info<< "compound from New (via pointer): "
            << ctok1.info() << nl << ctok1 << endl;
    }

    {
        // Construct from autoPtr
        autoPtr<token::compound> ptr
        (
            token::Compound<scalarList>::New(10, 1.0)
        );

        token ctok1(std::move(ptr));
        Info<< "compound from autoPtr: "
            << ctok1.info() << nl << ctok1 << endl;

        // Shrink
        ctok1.refCompoundToken().resize(5);

        Info<< "resized: "
            << ctok1.info() << nl << ctok1 << endl;

        // Using isA<> on compoundToken()
        if
        (
            const auto* listptr
          = ctok1.compoundToken().isA<scalarList>()
        )
        {
            // sneaky, SubField bypasses const!
            scalarField::subField fld(*listptr);
            fld *= 5;

            Info<< "multiplied List<scalar>: "
                << ctok1.info() << nl << ctok1 << endl;
        }

        // Using isCompound<...> - combined check
        if
        (
            const auto* listptr
          = ctok1.isCompound<scalarList>()
        )
        {
            scalarField::subField fld(*listptr);
            fld /= 2;

            Info<< "divided List<scalar>: "
                << ctok1.info() << nl << ctok1 << endl;
        }

        // Using isCompound<...> - combined check
        if
        (
            const auto* listptr
          = ctok1.isCompound<labelList>()
        )
        {
            labelField::subField fld(*listptr);
            fld /= 2;

            Info<< "divided List<label>: "
                << ctok1.info() << nl << ctok1 << endl;
        }
        else
        {
            Info<< "compound is not List<label>" << nl;
        }

        Info<< "Before fill_zero: " << ctok1 << endl;

        ctok1.refCompoundToken().fill_zero();

        Info<< "After fill_zero: " << ctok1 << endl;


        if (ctok1.isCompound())
        {
            auto& ct = ctok1.refCompoundToken();

            ct.resize(20);
            bool handled = false;

            switch (ct.typeCode())
            {
                #undef  doLocalCode
                #define doLocalCode(TokenType, cmptType, cmptValue)           \
                                                                              \
                case TokenType :                                              \
                {                                                             \
                    UList<cmptType> cmpts                                     \
                    (                                                         \
                        reinterpret_cast<cmptType*>(ct.data_bytes()),         \
                        label(ct.size_bytes() / sizeof(cmptType))             \
                    );                                                        \
                    cmpts = cmptValue;                                        \
                    handled = true;                                           \
                    break;                                                    \
                }

                doLocalCode(token::tokenType::BOOL, bool, false);
                doLocalCode(token::tokenType::LABEL, label, 123);
                doLocalCode(token::tokenType::FLOAT, float, 2.7);
                doLocalCode(token::tokenType::DOUBLE, double, 3.1415);

                #undef doLocalCode

                default : break;
            }


            if (handled)
            {
                Info<< "assigned: " << ctok1 << nl;
            }
            else
            {
                Info<< "Warning: not handled!" << nl;
            }
        }
    }


    Info << nl << "Assign / output of CHAR_DATA" << nl << nl;

    {
        OCharStream obuf;

        // Some content
        obuf
            << "// some char data content\n"
            << 1002 << " " << "abcd" << " "
            << "def" << " " << 3.14159 << ";\n"
            << "/* done */";

        token tok;

        if (auto v = obuf.view(); !v.empty())
        {
            tok = string(v.data(), v.size());
            tok.setType(token::tokenType::CHAR_DATA);
        }
        else
        {
            tok = token();
        }

        Info<< "tok: " << tok.name() << nl << nl;

        // Output like xml:
        Info<< "<![CDATA[" << tok << "]]>" << endl;

        obuf.rewind();

        obuf.beginBlock("dict1");
        obuf.writeEntry("entry0", 123);
        obuf.writeEntry("entry1", 3.14159);

        obuf.beginBlock("subDict");
        obuf.writeEntry("entry2", 1993);
        obuf.endBlock();

        obuf.endBlock();

        if (auto v = obuf.view(); !v.empty())
        {
            tok = string(v.data(), v.size());
            tok.setType(token::tokenType::CHAR_DATA);
        }
        else
        {
            tok = token();
        }

        // Output like xml:
        Info<< "<![CDATA[" << tok << "]]>" << endl;


        formattingEntry entry0(123, string(obuf.view().data(), obuf.size()));

        primitiveEntry entry1
        (
            "other",
            token
            (
                token::tokenType::CHAR_DATA,
                string(obuf.view().data(), obuf.size())
            )
        );

        Info<< "printing entry0: " << entry0.keyword() << nl;
        Info<< "content" << nl << entry0 << nl;

        Info<< "other content" << nl
            << entry1 << nl;

        // From pointer/length
        formattingEntry entry2(456, nullptr, 0);
        Info<< "printing entry2: " << entry2.keyword() << nl;
        Info<< "content" << nl << entry2 << nl;

        // From pointer/length
        formattingEntry entry3(23345, obuf.view().data(), obuf.view().size());
        Info<< "printing entry3: " << entry3.keyword() << nl;
        Info<< "content" << nl << entry3 << nl;
    }


    {
        primitiveEntry entry0("entry");

        Info<< "empty: " << entry0 << nl;

        // populate
        {
            tokenList& toks = entry0.stream();
            toks.resize(2);
            toks[0] = word("nonuniform");
            toks[1] = token::Compound<scalarList>::New(10, scalar(1));
        }

        Info<< entry0 << nl;

        // Modify contents
        for (auto& tok : entry0.stream())
        {
            if (tok.isCompound<scalarList>())
            {
                tok.refCompoundToken<scalarList>() = 2;
            }
        }

        Info<< entry0 << nl;


        // Find and 'capture' contents

        {
            typedef List<scalar> ListType;

            if
            (
                auto* inputDataPtr
              = const_cast<ListType*>(entry0.stream().findCompound<ListType>())
            )
            {
                Info<< "found input data" << nl;
                Info<< entry0 << nl;

                ListType inputData(std::move(*inputDataPtr));

                Info<< "input data, after move" << nl;
                Info<< entry0 << nl;

                ListType replaceData(5, scalar(3.145));

                // some manipulation
                replaceData.back() = scalar(1.414);

                inputDataPtr->swap(replaceData);
                Info<< "with replaced values" << nl;
            }
        }

        Info<< entry0 << nl;
    }

    return 0;
}


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