/*
 * Copyright 2011, Haiku, Inc. All rights reserved.
 * Copyright 2011, Clemens Zeidler <haiku@clemens-zeidler.de>
 * Distributed under the terms of the MIT License.
 */


#include "RowColumnManager.h"


#include <LayoutItem.h>


using namespace LinearProgramming;


namespace BALM {


RowColumnManager::RowColumnManager(LinearSpec* spec)
        :
        fLinearSpec(spec)
{

}


RowColumnManager::~RowColumnManager()
{
        for (int32 i = 0; i < fRows.CountItems(); i++)
                delete fRows.ItemAt(i)->fPrefSizeConstraint;

        for (int32 i = 0; i < fColumns.CountItems(); i++)
                delete fColumns.ItemAt(i)->fPrefSizeConstraint;
}

                                        
void
RowColumnManager::AddArea(Area* area)
{
        Row* row = _FindRowFor(area);
        if (row == NULL) {
                row = new Row(fLinearSpec, area->Top(), area->Bottom());
                fRows.AddItem(row);
        }
        area->fRow = row;
        row->fAreas.AddItem(area);

        Column* column = _FindColumnFor(area);
        if (column == NULL) {
                column = new Column(fLinearSpec, area->Left(), area->Right());
                fColumns.AddItem(column);
        }
        area->fColumn = column;
        column->fAreas.AddItem(area);

        _UpdateConstraints(row);
        _UpdateConstraints(column);
}


void
RowColumnManager::RemoveArea(Area* area)
{
        Row* row = area->fRow;
        if (row) {
                row->fAreas.RemoveItem(area);
                area->fRow = NULL;
                if (row->fAreas.CountItems() == 0) {
                        fRows.RemoveItem(row);
                        delete row;
                } else
                        _UpdateConstraints(row);
        }

        Column* column = area->fColumn;
        if (column) {
                column->fAreas.RemoveItem(area);
                area->fColumn = NULL;
                if (column->fAreas.CountItems() == 0) {
                        fColumns.RemoveItem(column);
                        delete column;
                } else
                        _UpdateConstraints(column);
        }
}


void
RowColumnManager::UpdateConstraints()
{
        for (int32 i = 0; i < fRows.CountItems(); i++)
                _UpdateConstraints(fRows.ItemAt(i));
        for (int32 i = 0; i < fColumns.CountItems(); i++)
                _UpdateConstraints(fColumns.ItemAt(i));
}


void
RowColumnManager::TabsChanged(Area* area)
{
        RemoveArea(area);
        AddArea(area);
}


Row*
RowColumnManager::_FindRowFor(Area* area)
{
        for (int32 i = 0; i < fRows.CountItems(); i++) {
                Row* row = fRows.ItemAt(i);
                if (row->fTop.Get() == area->Top()
                        && row->fBottom.Get() == area->Bottom())
                        return row;
        }
        return NULL;
}


Column*
RowColumnManager::_FindColumnFor(Area* area)
{
        for (int32 i = 0; i < fColumns.CountItems(); i++) {
                Column* column = fColumns.ItemAt(i);
                if (column->fLeft.Get() == area->Left()
                        && column->fRight.Get() == area->Right())
                        return column;
        }
        return NULL;
}


double
RowColumnManager::_PreferredHeight(Row* row, double& weight)
{
        weight = 0;
        int nAreas = 0;
        double pref = 0;
        for (int32 i = 0; i < row->fAreas.CountItems(); i++) {
                BSize prefSize = row->fAreas.ItemAt(i)->Item()->PreferredSize();
                if (prefSize.height <= 0)
                        continue;
                nAreas++;
                pref += prefSize.height;
                double negPen = row->fAreas.ItemAt(i)->ShrinkPenalties().height;
                if (negPen > 0)
                        weight += negPen;
        }
        if (nAreas == 0) {
                pref = -1;
                weight = 1;
        } else {
                pref /= nAreas;
                weight /= nAreas;
        }
        return pref;
}


double
RowColumnManager::_PreferredWidth(Column* column, double& weight)
{
        weight = 0;
        int nAreas = 0;
        double pref = 0;
        for (int32 i = 0; i < column->fAreas.CountItems(); i++) {
                BSize prefSize = column->fAreas.ItemAt(i)->Item()->PreferredSize();
                if (prefSize.width <= 0)
                        continue;
                nAreas++;
                pref += prefSize.width;

                double negPen = column->fAreas.ItemAt(i)->ShrinkPenalties().height;
                if (negPen > 0)
                        weight += negPen;
        }
        if (nAreas == 0) {
                pref = -1;
                weight = 1;
        } else {
                pref /= nAreas;
                weight /= nAreas;
        }
        return pref;
}


void
RowColumnManager::_UpdateConstraints(Row* row)
{
        double weight;
        double prefSize = _PreferredHeight(row, weight);
        if (prefSize >= 0) {
                if (row->fPrefSizeConstraint == NULL) {
                        row->fPrefSizeConstraint = fLinearSpec->AddConstraint(1,
                                row->fBottom, -1, row->fTop, kEQ, prefSize, weight, weight);
                        row->fPrefSizeConstraint->SetLabel("Pref Height");
                } else {
                        row->fPrefSizeConstraint->SetRightSide(prefSize);
                        row->fPrefSizeConstraint->SetPenaltyNeg(weight);
                        row->fPrefSizeConstraint->SetPenaltyPos(weight);
                }
        } else {
                delete row->fPrefSizeConstraint;
                row->fPrefSizeConstraint = NULL;
        }
}


void
RowColumnManager::_UpdateConstraints(Column* column)
{
        double weight;
        double prefSize = _PreferredWidth(column, weight);
        if (prefSize >= 0) {
                if (column->fPrefSizeConstraint == NULL) {
                        column->fPrefSizeConstraint = fLinearSpec->AddConstraint(1,
                                column->fRight, -1, column->fLeft, kEQ, prefSize, weight,
                                weight);
                        column->fPrefSizeConstraint->SetLabel("Pref Width");
                } else {
                        column->fPrefSizeConstraint->SetRightSide(prefSize);
                        column->fPrefSizeConstraint->SetPenaltyNeg(weight);
                        column->fPrefSizeConstraint->SetPenaltyPos(weight);
                }
        } else {
                delete column->fPrefSizeConstraint;
                column->fPrefSizeConstraint = NULL;
        }
}


} // end BALM namespace