/*
 * Copyright 2012, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "SharedSolver.h"

#include <set>

#include <ALMLayout.h>
#include <AutoDeleter.h>
#include <ObjectList.h>

#include "RowColumnManager.h"


using LinearProgramming::LinearSpec;


namespace {

type_code kConstraintsTypeCode = 'cnst';
const char* kConstraintsField = "SharedSolver:constraints";

};


struct SharedSolver::MinSizeValidator {
        inline void CallSolverMethod(LinearSpec* spec, VariableList* vars)
        {
                spec->FindMins(vars);
        }

        inline void Finalize(BALMLayout* layout, SharedSolver* solver,
                ResultType solveResult)
        {
                if (solveResult == LinearProgramming::kUnbounded) {
                        solver->SetMinSize(layout, BSize(0, 0));
                } else {
                        solver->SetMinSize(layout, BSize(ceilf(layout->Right()->Value()),
                                ceilf(layout->Bottom()->Value())));
                }
        }
};


struct SharedSolver::MaxSizeValidator {
        inline void CallSolverMethod(LinearSpec* spec, VariableList* vars)
        {
                spec->FindMaxs(vars);
        }

        inline void Finalize(BALMLayout* layout, SharedSolver* solver,
                ResultType solveResult)
        {
                if (solveResult == LinearProgramming::kUnbounded) {
                        solver->SetMaxSize(layout,
                                BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
                } else {
                        solver->SetMaxSize(layout, BSize(floorf(layout->Right()->Value()),
                                floorf(layout->Bottom()->Value())));
                }
        }
};


struct SharedSolver::PreferredSizeValidator {
        inline void CallSolverMethod(LinearSpec* spec, VariableList* vars)
        {
                spec->Solve();
        }

        inline void Finalize(BALMLayout* layout, SharedSolver* solver,
                ResultType solveResult)
        {
                float width = layout->Right()->Value() - layout->Left()->Value();
                float height = layout->Bottom()->Value() - layout->Top()->Value();
                solver->SetPreferredSize(layout, BSize(width, height));
        }
};


SharedSolver::SharedSolver()
        :
        fConstraintsValid(false),
        fMinValid(false),
        fMaxValid(false),
        fPreferredValid(false),
        fLayoutValid(false),
        fLayoutContext(NULL)
{
}


SharedSolver::SharedSolver(BMessage* archive)
        :
        BArchivable(archive),
        fConstraintsValid(false),
        fMinValid(false),
        fMaxValid(false),
        fPreferredValid(false),
        fLayoutValid(false),
        fLayoutContext(NULL)
{
}


SharedSolver::~SharedSolver()
{
        if (fLayouts.CountItems() > 0)
                debugger("SharedSolver deleted while still in use!");

        _SetContext(NULL);
}


LinearSpec*
SharedSolver::Solver() const
{
        return const_cast<LinearSpec*>(&fLinearSpec);
}


void
SharedSolver::Invalidate(bool children)
{
        if (!fConstraintsValid && !fMaxValid && !fMinValid && !fLayoutValid)
                return;

        fConstraintsValid = false;
        fMinValid = false;
        fMaxValid = false;
        fPreferredValid = false;
        fLayoutValid = false;

        _SetContext(NULL);

        for (int32 i = fLayouts.CountItems() - 1; i >= 0; i--)
                fLayouts.ItemAt(i)->InvalidateLayout(children);
}


void
SharedSolver::RegisterLayout(BALMLayout* layout)
{
        fLayouts.AddItem(layout);
        Invalidate(false);
}


void
SharedSolver::LayoutLeaving(const BALMLayout* layout)
{
        fLayouts.RemoveItem(const_cast<BALMLayout*>(layout));
        Invalidate(false);
}


ResultType
SharedSolver::ValidateMinSize()
{
        _Validate<MinSizeValidator>(fMinValid, fMinResult);
        return fMinResult;
}


ResultType
SharedSolver::ValidateMaxSize()
{
        _Validate<MaxSizeValidator>(fMaxValid, fMaxResult);
        return fMaxResult;
}


ResultType
SharedSolver::ValidatePreferredSize()
{
        _Validate<PreferredSizeValidator>(fPreferredValid, fPreferredResult);
        return fPreferredResult;
}


ResultType
SharedSolver::ValidateLayout(BLayoutContext* context)
{
        if (fLayoutValid && fLayoutContext == context)
                return fLayoutResult;

        _SetContext(context);
        _ValidateConstraints();

        for (int32 i = fLayouts.CountItems() - 1; i >= 0; i--) {
                BALMLayout* layout = fLayouts.ItemAt(i);
                BSize size(layout->LayoutArea().Size());
                layout->Right()->SetRange(size.width, size.width);
                layout->Bottom()->SetRange(size.height, size.height);
        }

        fLayoutResult = fLinearSpec.Solve();
        fLayoutValid = true;
        return fLayoutResult;
}


status_t
SharedSolver::Archive(BMessage* archive, bool deep) const
{
        return BArchivable::Archive(archive, deep);
}


status_t
SharedSolver::AllArchived(BMessage* archive) const
{
        /*
        for each archived layout:
                add it to our archive
                add constraints created by areas and column manager to a set
                add range constraints on the left/top/right/bottom tabs to the same set
        for each constraint in the linear spec:
                if it is not in the set above:
                        archive it
        */
        BArchiver archiver(archive);
        std::set<const Constraint*> autoConstraints;
        for (int32 i = fLayouts.CountItems() - 1; i >= 0; i--) {
                BALMLayout* layout = fLayouts.ItemAt(i);
                if (!archiver.IsArchived(layout))
                        continue;

                for (int32 j = layout->CountItems() - 1; j >= 0; j--)
                        _AddConstraintsToSet(layout->AreaAt(j), autoConstraints);

                for (int32 j = layout->fRowColumnManager->fRows.CountItems() - 1;
                                j >= 0; j--) {
                        Row* row = layout->fRowColumnManager->fRows.ItemAt(j);
                        autoConstraints.insert(row->fPrefSizeConstraint);
                }

                for (int32 j = layout->fRowColumnManager->fColumns.CountItems() - 1;
                                j >= 0; j--) {
                        Column* column = layout->fRowColumnManager->fColumns.ItemAt(j);
                        autoConstraints.insert(column->fPrefSizeConstraint);
                }

                Variable* corners[] = {layout->fLeft, layout->fTop, layout->fRight,
                        layout->fBottom};

                for (int32 j = 0; j < 4; j++) {
                        const Constraint* min;
                        const Constraint* max;
                        fLinearSpec.GetRangeConstraints(corners[j], &min, &max);
                        if (min)
                                autoConstraints.insert(min);
                        if (max)
                                autoConstraints.insert(max);
                }
        }

        status_t err = B_OK;
        const ConstraintList& constraints = fLinearSpec.Constraints();
        for (int32 i = constraints.CountItems() - 1; i >= 0 && err == B_OK; i--) {
                Constraint* constraint = constraints.ItemAt(i);
                if (autoConstraints.find(constraint) == autoConstraints.end())
                        err = _AddConstraintToArchive(constraint, archive);
        }
        return err;
}


status_t
SharedSolver::AllUnarchived(const BMessage* archive)
{
        int32 count = 0;
        archive->GetInfo(kConstraintsField, NULL, &count);

        status_t err = B_OK;
        BUnarchiver unarchiver(archive);
        for (int32 i = 0; i < count && err == B_OK; i++) {
                const void* constraintData;
                ssize_t numBytes;
                err = archive->FindData(kConstraintsField, kConstraintsTypeCode,
                        i, &constraintData, &numBytes);
                if (err != B_OK)
                        return err;

                err = _InstantiateConstraint(constraintData, numBytes, unarchiver);
        }
        return err;
}


void
SharedSolver::_AddConstraintsToSet(Area* area,
        std::set<const Constraint*>& constraints)
{
        if (area->fMinContentWidth)
                constraints.insert(area->fMinContentWidth);
        if (area->fMaxContentWidth)
                constraints.insert(area->fMaxContentWidth);
        if (area->fMinContentHeight)
                constraints.insert(area->fMinContentHeight);
        if (area->fMaxContentHeight)
                constraints.insert(area->fMaxContentHeight);
        if (area->fContentAspectRatioC)
                constraints.insert(area->fContentAspectRatioC);
}


status_t
SharedSolver::_AddConstraintToArchive(Constraint* constraint,
        BMessage* archive)
{
        /* Format:
         * int32: summandCount
         *  { int32 : token
         *    double: coefficient
         *  } [summandCount]    
         *  int32: operator
         *  double: rightSide
         *  double: penaltyNeg
         *  double: penaltyPos
         */

        // TODO: check Read/Write calls
        BArchiver archiver(archive);
        BMallocIO buffer;
        SummandList* leftSide = constraint->LeftSide();
        int32 summandCount = leftSide->CountItems();
        buffer.Write(&summandCount, sizeof(summandCount));

        for (int32 i = 0; i < summandCount; i++) {
                Summand* summand = leftSide->ItemAt(i);
                Variable* var = summand->Var();
                BArchivable* varArchivable = dynamic_cast<BArchivable*>(var);
                if (!varArchivable || !archiver.IsArchived(varArchivable))
                        return B_NAME_NOT_FOUND;

                int32 token;
                archiver.GetTokenForArchivable(varArchivable, token);
                buffer.Write(&token, sizeof(token));

                double coefficient = summand->Coeff();
                buffer.Write(&coefficient, sizeof(coefficient));
        }

        int32 op = constraint->Op();
        buffer.Write(&op, sizeof(op));

        double rightSide = constraint->RightSide();
        buffer.Write(&rightSide, sizeof(rightSide));
        double penaltyNeg = constraint->PenaltyNeg();
        buffer.Write(&penaltyNeg, sizeof(penaltyNeg));
        double penaltyPos = constraint->PenaltyPos();
        buffer.Write(&penaltyPos, sizeof(penaltyPos));

        return archive->AddData(kConstraintsField, kConstraintsTypeCode,
                buffer.Buffer(), buffer.BufferLength(), false);
}


status_t
SharedSolver::_InstantiateConstraint(const void* rawData, ssize_t numBytes,
        BUnarchiver& unarchiver)
{
        /* Format:
         * int32: summandCount
         *  { int32 : token
         *    double: coefficient
         *  } [summandCount]    
         *  int32: operator
         *  double: rightSide
         *  double: penaltyNeg
         *  double: penaltyPos
         */

        // TODO: check Read/Write calls
        BMemoryIO buffer(rawData, numBytes);
        int32 summandCount;
        buffer.Read((void*)&summandCount, sizeof(summandCount));

        SummandList* summandList = new SummandList(20);
        ObjectDeleter<SummandList> deleter(summandList);
        status_t err = B_OK;
        for (int32 i = 0; i < summandCount; i++) {
                int32 token;
                buffer.Read((void*)&token, sizeof(token));

                BArchivable* varArchivable;
                err = unarchiver.GetObject(token, varArchivable);
                if (err != B_OK)
                        break;
                Variable* var = dynamic_cast<Variable*>(varArchivable);
                if (!var)
                        return B_BAD_TYPE;

                fLinearSpec.AddVariable(var);

                double coefficient;
                buffer.Read(&coefficient, sizeof(coefficient));

                summandList->AddItem(new Summand(coefficient, var));
        }

        int32 op;
        buffer.Read(&op, sizeof(op));

        double rightSide;
        buffer.Read(&rightSide, sizeof(rightSide));
        double penaltyNeg;
        buffer.Read(&penaltyNeg, sizeof(penaltyNeg));
        double penaltyPos;
        buffer.Read(&penaltyPos, sizeof(penaltyPos));

        if (err != B_OK)
                return err;

        if (fLinearSpec.AddConstraint(summandList, (OperatorType)op, rightSide,
                        penaltyNeg, penaltyPos) != NULL) {
                deleter.Detach();
                return B_OK;
        }

        return B_NO_MEMORY;
}


void
SharedSolver::SetMaxSize(BALMLayout* layout, const BSize& max)
{
        layout->fMaxSize = max;
}


void
SharedSolver::SetMinSize(BALMLayout* layout, const BSize& min)
{
        layout->fMinSize = min;
}


void
SharedSolver::SetPreferredSize(BALMLayout* layout, const BSize& preferred)
{
        layout->fPreferredSize = preferred;
}


void
SharedSolver::LayoutContextLeft(BLayoutContext* context)
{
        fLayoutContext = NULL;
}


void
SharedSolver::_SetContext(BLayoutContext* context)
{
        if (fLayoutContext)
                fLayoutContext->RemoveListener(this);
        fLayoutContext = context;
        if (fLayoutContext)
                fLayoutContext->AddListener(this);
}


void
SharedSolver::_ValidateConstraints()
{
        if (!fConstraintsValid) {
                for (int32 i = fLayouts.CountItems() - 1; i >= 0; i--) {
                        fLayouts.ItemAt(i)->UpdateConstraints(fLayoutContext);
                }
                fConstraintsValid = true;
        }
}


template <class Validator>
void
SharedSolver::_Validate(bool& isValid, ResultType& result)
{
        if (isValid)
                return;

        _ValidateConstraints();

        VariableList variables(fLayouts.CountItems() * 2);
        Validator validator;

        for (int32 i = fLayouts.CountItems() - 1; i >= 0; i--) {
                BALMLayout* layout = fLayouts.ItemAt(i);
                layout->Right()->SetRange(0, 20000);
                layout->Bottom()->SetRange(0, 20000);

                variables.AddItem(layout->Right());
                variables.AddItem(layout->Bottom());
        }

        validator.CallSolverMethod(&fLinearSpec, &variables);
        result = fLinearSpec.Result();

        for (int32 i = fLayouts.CountItems() - 1; i >= 0; i--)
                validator.Finalize(fLayouts.ItemAt(i), this, result);

        isValid = true;
        fLayoutValid = false;
}


BArchivable*
SharedSolver::Instantiate(BMessage* archive)
{
        if (validate_instantiation(archive, "BPrivate::SharedSolver"))
                return new SharedSolver(archive);
        return NULL;
}