#include "ToolTip.h"

#include "AlphaFeld.h"
#include "Bild.h"
#include "Bildschirm.h"
#include "MausEreignis.h"
#include "Rahmen.h"
#include "Schrift.h"
#include "Scroll.h"
#include "Text.h"
#include "TextFeld.h"

using namespace Framework;

// Inhalt der ToolTip Klasse aus ToolTip.h
// Konstruktor
ToolTip::ToolTip(Bildschirm* zScreen)
    : ZeichnungHintergrund(),
      size(0, 0),
      animationSpeed(250),
      warten(1),
      wartenCount(0),
      tval(0),
      mausIn(0),
      alpha(0),
      sichtbar(0),
      zeichnen(0),
      mausIn2(0),
      bildschirm(zScreen),
      onShow(0),
      onHide(0)
{
    style = Style::MEIgnoreInside | Style::MEIgnoreParentInside
          | Style::MEIgnoreSichtbar | Style::MEIgnoreVerarbeitet
          | Style::Erlaubt;
    members = new RCArray<Zeichnung>();
    bildschirm->addToolTip(dynamic_cast<ToolTip*>(this->getThis()));
    setMausEreignis(_ret1ME);
}

// Destruktor
ToolTip::~ToolTip()
{
    members->release();
}

void ToolTip::doMausEreignis(MausEreignis& me, bool userRet)
{
    if (!sichtbar) pos.x += me.mx, pos.y += me.my + 15;
    if (hatStyleNicht(Style::Sichtbar) || !me.insideParent || me.verarbeitet
        || me.mx < 0 || me.my < 0 || me.mx >= gr.x || me.my >= gr.y || !userRet)
    {
        mausIn2 = 0;
        if (!mausIn && sichtbar)
        {
            if (onHide && sichtbar) onHide(this);
            sichtbar = 0;
        }
        bool verarbeitet = me.verarbeitet;
        me.verarbeitet |= hatStyleNicht(Style::Sichtbar);
        bool insideParent = me.insideParent;
        me.insideParent = 0;
        int rbr = 0;
        if (hatStyle(Style::Rahmen) && rahmen) rbr = rahmen->getRBreite();
        me.mx -= rbr;
        me.my -= rbr;
        if (hatStyle(Style::VScroll) && vertikalScrollBar)
            me.my += vertikalScrollBar->getScroll();
        if (hatStyle(Style::HScroll) && horizontalScrollBar)
            me.mx += horizontalScrollBar->getScroll();
        if (me.id != ME_Betritt && me.id != ME_Leaves)
        {
            for (int i = members->getEintragAnzahl() - 1; i >= 0; i--)
                members->z(i)->doPublicMausEreignis(me);
        }
        me.mx += rbr;
        me.my += rbr;
        if (hatStyle(Style::VScroll) && vertikalScrollBar)
            me.my -= vertikalScrollBar->getScroll();
        if (hatStyle(Style::HScroll) && horizontalScrollBar)
            me.mx -= horizontalScrollBar->getScroll();
        me.insideParent = insideParent;
        if (hatStyleNicht(Style::Sichtbar)) me.verarbeitet = verarbeitet;
        return;
    }
    mausIn2 = 1;
    if (sichtbar)
    {
        int rbr = 0;
        if (hatStyle(Style::Rahmen) && rahmen) rbr = rahmen->getRBreite();
        me.mx -= rbr;
        me.my -= rbr;
        if (hatStyle(Style::VScroll) && vertikalScrollBar)
            me.my += vertikalScrollBar->getScroll();
        if (hatStyle(Style::HScroll) && horizontalScrollBar)
            me.mx += horizontalScrollBar->getScroll();
        for (auto z : *members)
            z->doPublicMausEreignis(me);
        me.mx += rbr;
        me.my += rbr;
        if (hatStyle(Style::VScroll) && vertikalScrollBar)
            me.my -= vertikalScrollBar->getScroll();
        if (hatStyle(Style::HScroll) && horizontalScrollBar)
            me.mx -= horizontalScrollBar->getScroll();
    }
    if (sichtbar) me.verarbeitet = 1;
    if (alpha) rend = 1;
}

// Fügt eine Zeichnung zum Tooltip hinzu
//  m: die neue Zeichnung
void ToolTip::addMember(Zeichnung* m)
{
    members->add(m);
}

void ToolTip::removeMember(Zeichnung* zM)
{
    int index = 0;
    for (auto i : *members)
    {
        if (i == zM)
        {
            members->remove(index);
            return;
        }
        index++;
    }
}

// Entfernt eine Zeichnung vom Tooltip
//  i: der Index der Zeichnung
void ToolTip::removeMember(int i)
{
    members->remove(i);
}

// setzt eine Funktion, die aufgerufen wird, sobald der Tooltip angezeigt wird
//  onShow: Die Funktion
void ToolTip::setShowEvent(std::function<void(ToolTip*)> onShow)
{
    this->onShow = onShow;
}

// setzt eine Funktion, die aufgerufen wird, sobald der Tooltip nicht mehr
// angezeigt wird
//  onShow: Die Funktion
void ToolTip::setHideEvent(std::function<void(ToolTip*)> onHide)
{
    this->onHide = onHide;
}

void ToolTip::setWarten(double warten)
{
    this->warten = warten;
}

void ToolTip::setAnimationSpeed(double speed)
{
    animationSpeed = speed;
}

void ToolTip::setMausIn(bool mausIn)
{
    if (this->mausIn != mausIn) rend = 1;
    this->mausIn = mausIn;
    if (!mausIn && !mausIn2 && sichtbar)
    {
        if (sichtbar && onHide) onHide(this);
        sichtbar = 0;
    }
}

void ToolTip::wartenReset()
{
    wartenCount = 0;
}

void ToolTip::setZeichnen()
{
    zeichnen = 1;
}

bool ToolTip::tick(double tickVal)
{
    for (auto z : *members)
    {
        size.x
            = MAX(size.x, z->getX() + z->getBreite() + 2 * getRahmenBreite());
        size.y
            = MAX(size.y, z->getY() + z->getHeight() + 2 * getRahmenBreite());
    }
    this->tval += tickVal * animationSpeed;
    int val = (int)this->tval;
    if (val < 1)
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    this->tval -= val;
    if (!sichtbar)
    {
        if (alpha)
        {
            if (alpha - val < 0)
                alpha = 0;
            else
                alpha = (unsigned char)(alpha - val);
            rend = 1;
        }
        if (mausIn)
        {
            wartenCount += tickVal;
            if (wartenCount >= warten)
            {
                if (onShow) onShow(this);
                sichtbar = 1;
                wartenCount = 0;
                alpha = 0xFF;
                ZeichnungHintergrund::setSize(0, 0);
            }
        }
        else
            wartenCount = 0;
    }
    else
    {
        if (getBreite() < size.x)
        {
            ZeichnungHintergrund::setSize(getBreite() + val, getHeight());
            if (getBreite() > size.x)
                ZeichnungHintergrund::setSize(size.x, getHeight());
            rend = 1;
        }
        if (getHeight() < size.y)
        {
            ZeichnungHintergrund::setSize(getBreite(), getHeight() + val);
            if (getHeight() > size.y)
                ZeichnungHintergrund::setSize(getBreite(), size.y);
            rend = 1;
        }
    }
    return ZeichnungHintergrund::tick(tickVal);
}

void ToolTip::render(Bild& zRObj)
{
    if (alpha && (zeichnen || mausIn2))
    {
        zRObj.setAlpha(alpha);
        setPosition(pos);
        if (getX() + getBreite() > zRObj.getBreite())
            setPosition(
                getX() - (getX() + getBreite() - zRObj.getBreite()), getY());
        if (getY() + getHeight() > zRObj.getHeight())
            setPosition(
                getX(), getY() - (getY() + getHeight() - zRObj.getHeight()));
        ZeichnungHintergrund::render(zRObj);
        Punkt p = pos;
        Punkt s = gr;
        if (hatStyle(ZeichnungHintergrund::Style::Rahmen))
        {
            p += Punkt(getRahmenBreite(), getRahmenBreite());
            s -= Punkt(getRahmenBreite(), getRahmenBreite()) * 2;
        }
        if (!zRObj.setDrawOptions(p, s))
        {
            zRObj.releaseAlpha();
            zeichnen = 0;
            return;
        }
        bool vSc = hatStyle(Style::VScroll) && vertikalScrollBar;
        bool hSc = hatStyle(Style::HScroll) && horizontalScrollBar;
        zRObj.addScrollOffset(hSc ? horizontalScrollBar->getScroll() : 0,
            vSc ? vertikalScrollBar->getScroll() : 0);
        for (auto z : *members)
            z->render(zRObj);
        zRObj.releaseDrawOptions();
        zRObj.releaseAlpha();
        zeichnen = 0;
    }
}

// constant
Bildschirm* ToolTip::zBildschirm() const
{
    return bildschirm;
}

// Gibt ein bestimmten member zurück (ohne erhöhten Reference Counter)
//  i: der Index des Members
Zeichnung* ToolTip::zMember(int i) const
{
    return members->z(i);
}

// Gibt ein bestimmten member zurück
//  i: der Index des Members
Zeichnung* ToolTip::getMember(int i) const
{
    return members->get(i);
}

// Gibt die Anzahl an Zeichnungen zurück, die zum Tooltip gehören
int ToolTip::getMemberAnzahl() const
{
    return members->getEintragAnzahl();
}

// Erzeugt eine komplette kopie eines tooltip
Zeichnung* ToolTip::dublizieren() const
{
    ToolTip* ret = new ToolTip(bildschirm);
    ret->size = size;
    ret->animationSpeed = animationSpeed;
    ret->warten = warten;
    ret->wartenCount = wartenCount;
    ret->tval = tval;
    ret->mausIn = mausIn;
    ret->alpha = alpha;
    ret->sichtbar = sichtbar;
    ret->zeichnen = zeichnen;
    ret->mausIn2 = mausIn2;
    for (auto z : *members)
        ret->addMember(dynamic_cast<Zeichnung*>(z->getThis()));
    return ret;
}

//! Prüft ob der Tooltip im moment angezeigt wird
DLLEXPORT bool ToolTip::isVisible() const
{
    return sichtbar;
}