#include "ShapedRecipie.h"

#include <Bild.h>
#include <XML.h>

ShapedRecipieElement::ShapedRecipieElement()
    : Framework::UIMLElement()
{}

//! prüft, ob dieses UIML Element für ein bestimmtes xml Element zuständig
//! ist
bool ShapedRecipieElement::isApplicableFor(Framework::XML::Element& element)
{
    return element.getName().istGleich("recipie")
        && element.getAttributeValue("type").istGleich("shaped");
}

//! erstellt eine neue Zeichnung zu einem gegebenen xml Element
Framework::Zeichnung* ShapedRecipieElement::parseElement(
    Framework::XML::Element& element, Framework::UIMLContainer& generalFactory)
{
    int width = (int)element.getAttributeValue("width");
    int height = (int)element.getAttributeValue("height");
    ShapedRecipie* recipie = new ShapedRecipie(width, height);

    element.selectChildsByName("ingredients")
        .selectChildren()
        .forEach([recipie, &generalFactory](Framework::XML::Element* zElement) {
            recipie->addIngredient(
                generalFactory.parseElement(*zElement, generalFactory));
        });

    element.selectChildsByName("outputs").selectChildren().forEach(
        [recipie, &generalFactory](Framework::XML::Element* zElement) {
            recipie->addOutput(
                generalFactory.parseElement(*zElement, generalFactory));
        });

    return recipie;
}

bool ShapedRecipieElement::updateElement(Framework::XML::Element& element,
    Framework::Zeichnung& z,
    Framework::UIMLContainer& generalFactory)
{
    return false;
}

//! wendet die layout parameter zu einer Zeichnung an
void ShapedRecipieElement::layout(Framework::XML::Element& element,
    Framework::Zeichnung& z,
    int pWidth,
    int pHeight,
    Framework::UIMLContainer& generalLayouter)
{
    UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
    int width = (int)element.getAttributeValue("width");
    int height = (int)element.getAttributeValue("height");
    int outputs
        = element.selectChildsByName("outputs").selectChildren().getSize();
    int outputCols = outputs / height;
    if (outputs % height != 0)
    {
        outputCols++;
    }
    if (outputCols == 0)
    {
        outputCols = 1;
    }
    z.setWidth(width * 60 + 50 + outputCols * 60 - 10);
    z.setHeight(height * 60 - 10);
    element.selectChildren().selectChildren().forEach(
        [&z, &generalLayouter](Framework::XML::Element* zElement) {
            Framework::Zeichnung* child = 0;
            if (zElement->hasAttribute("id"))
            {
                child = generalLayouter.zZeichnungById(
                    zElement->getAttributeValue("id"));
            }
            if (child)
            {
                generalLayouter.layout(*zElement,
                    *child,
                    z.getBreite(),
                    z.getHeight(),
                    generalLayouter);
            }
        });
}

ShapedRecipie::ShapedRecipie(int width, int height)
    : Framework::ZeichnungHintergrund(),
      width(width),
      height(height)
{
    setStyle(Framework::Zeichnung::Style::Erlaubt
             | Framework::Zeichnung::Style::Sichtbar);
}

void ShapedRecipie::addIngredient(Zeichnung* ingredient)
{
    ingredients.add(ingredient);
}

void ShapedRecipie::addOutput(Zeichnung* output)
{
    outputs.add(output);
}

bool ShapedRecipie::tick(double tickVal)
{
    bool ret = false;
    for (Zeichnung* ingredient : ingredients)
    {
        ret |= ingredient->tick(tickVal);
    }
    for (Zeichnung* output : outputs)
    {
        ret |= output->tick(tickVal);
    }
    return ret;
}

void ShapedRecipie::render(Framework::Bild& rObj)
{
    if (!hatStyle(Zeichnung::Style::Sichtbar)) return;
    ZeichnungHintergrund::render(rObj);
    if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
    int x = 0;
    int y = 0;
    for (Zeichnung* ingredient : ingredients)
    {
        ingredient->setX(x);
        ingredient->setY(y);
        ingredient->render(rObj);
        x += 60;
        if (x >= width * 60)
        {
            x = 0;
            y += 60;
        }
    }
    rObj.fillRegion(width * 60, gr.y / 2 - 5, 25, 10, 0xFF52525E);
    rObj.drawDreieck(Framework::Punkt(width * 60 + 25, gr.y / 2 - 15),
        Framework::Punkt(width * 60 + 40, gr.y / 2),
        Framework::Punkt(width * 60 + 25, gr.y / 2 + 15),
        0xFF52525E);
    x = width * 60 + 50;
    y = 0;
    for (Zeichnung* output : outputs)
    {
        output->setX(x);
        output->setY(y);
        output->render(rObj);
        y += 60;
    }
    rObj.releaseDrawOptions();
}

void ShapedRecipie::doMausEreignis(Framework::MausEreignis& me, bool userRet)
{
    for (Zeichnung* ingredient : ingredients)
    {
        ingredient->doPublicMausEreignis(me);
    }
    for (Zeichnung* output : outputs)
    {
        output->doPublicMausEreignis(me);
    }
}