#include <stdio.h>

#include <List.h>
#include <View.h> // for resize modes

#include "Desktop.h"
#include "DrawingEngine.h"
#include "WindowLayer.h"

#include "ViewLayer.h"

extern BWindow* wind;

// constructor
ViewLayer::ViewLayer(BRect frame, const char* name,
                         uint32 resizeMode, uint32 flags,
                         rgb_color viewColor)
        : fName(name),

          fFrame(frame),
          fScrollingOffset(0.0, 0.0),

          fViewColor(viewColor),

          fResizeMode(resizeMode),
          fFlags(flags),

          // ViewLayers start visible by default
          fHidden(false),
          fVisible(true),

          fWindow(NULL),
          fParent(NULL),

          fFirstChild(NULL),
          fPreviousSibling(NULL),
          fNextSibling(NULL),
          fLastChild(NULL),

          fCurrentChild(NULL),

          fLocalClipping(Bounds()),
          fScreenClipping(),
          fScreenClippingValid(false)
{
        fFrame.left = float((int32)fFrame.left);
        fFrame.top = float((int32)fFrame.top);
        fFrame.right = float((int32)fFrame.right);
        fFrame.bottom = float((int32)fFrame.bottom);
}

// destructor
ViewLayer::~ViewLayer()
{
        // iterate over children and delete each one
        ViewLayer* layer = fFirstChild;
        while (layer) {
                ViewLayer* toast = layer;
                layer = layer->fNextSibling;
                delete toast;
        }
}

// Bounds
BRect
ViewLayer::Bounds() const
{
        BRect bounds(fScrollingOffset.x, fScrollingOffset.y,
                                 fScrollingOffset.x + fFrame.Width(),
                                 fScrollingOffset.y + fFrame.Height());
        return bounds;
}

// ConvertToVisibleInTopView
void
ViewLayer::ConvertToVisibleInTopView(BRect* bounds) const
{
        *bounds = *bounds & Bounds();
        // NOTE: this step is necessary even if we don't have a parent!
        ConvertToParent(bounds);

        if (fParent)
                fParent->ConvertToVisibleInTopView(bounds);
}

// AttachedToWindow
void
ViewLayer::AttachedToWindow(WindowLayer* window)
{
        fWindow = window;

        for (ViewLayer* child = FirstChild(); child; child = NextChild())
                child->AttachedToWindow(window);
}


// DetachedFromWindow
void
ViewLayer::DetachedFromWindow()
{
        fWindow = NULL;
        for (ViewLayer* child = FirstChild(); child; child = NextChild())
                child->DetachedFromWindow();
}

// AddChild
void
ViewLayer::AddChild(ViewLayer* layer)
{
        if (layer->fParent) {
                printf("ViewLayer::AddChild() - ViewLayer already has a parent\n");
                return;
        }
        
        layer->fParent = this;
        
        if (!fLastChild) {
                // no children yet
                fFirstChild = layer;
        } else {
                // append layer to formerly last child
                fLastChild->fNextSibling = layer;
                layer->fPreviousSibling = fLastChild;
        }
        fLastChild = layer;

        if (layer->IsVisible())
                RebuildClipping(false);

        if (fWindow) {
                layer->AttachedToWindow(fWindow);

                if (fVisible && layer->IsVisible()) {
                        // trigger redraw
                        BRect clippedFrame = layer->Frame();
                        ConvertToVisibleInTopView(&clippedFrame);
                        BRegion dirty(clippedFrame);
                        fWindow->MarkContentDirty(&dirty);
                }
        }
}

// RemoveChild
bool
ViewLayer::RemoveChild(ViewLayer* layer)
{
        if (layer->fParent != this) {
                printf("ViewLayer::RemoveChild(%p - %s) - ViewLayer is not child of this (%p) layer!\n", layer, layer ? layer->Name() : NULL, this);
                return false;
        }
        
        layer->fParent = NULL;
        
        if (fLastChild == layer)
                fLastChild = layer->fPreviousSibling;
                // layer->fNextSibling would be NULL
        
        if (fFirstChild == layer )
                fFirstChild = layer->fNextSibling;
                // layer->fPreviousSibling would be NULL

        // connect child before and after layer
        if (layer->fPreviousSibling)
                layer->fPreviousSibling->fNextSibling = layer->fNextSibling;
        
        if (layer->fNextSibling)
                layer->fNextSibling->fPreviousSibling = layer->fPreviousSibling;

        // layer has no siblings anymore
        layer->fPreviousSibling = NULL;
        layer->fNextSibling = NULL;

        if (layer->IsVisible())
                RebuildClipping(false);

        if (fWindow) {
                layer->DetachedFromWindow();

                if (fVisible && layer->IsVisible()) {
                        // trigger redraw
                        BRect clippedFrame = layer->Frame();
                        ConvertToVisibleInTopView(&clippedFrame);
                        BRegion dirty(clippedFrame);
                        fWindow->MarkContentDirty(&dirty);
                }
        }

        return true;
}

// FirstChild
ViewLayer*
ViewLayer::FirstChild() const
{
        fCurrentChild = fFirstChild;
        return fCurrentChild;
}

// PreviousChild
ViewLayer*
ViewLayer::PreviousChild() const
{
        fCurrentChild = fCurrentChild->fPreviousSibling;
        return fCurrentChild;
}

// NextChild
ViewLayer*
ViewLayer::NextChild() const
{
        fCurrentChild = fCurrentChild->fNextSibling;
        return fCurrentChild;
}

// LastChild
ViewLayer*
ViewLayer::LastChild() const
{
        fCurrentChild = fLastChild;
        return fCurrentChild;
}

// TopLayer
ViewLayer*
ViewLayer::TopLayer()
{
        // returns the top level view of the hirarchy,
        // it doesn't have to be the top level of a window

        if (fParent)
                return fParent->TopLayer();

        return this;
}

// CountChildren
uint32
ViewLayer::CountChildren(bool deep) const
{
        uint32 count = 0;
        for (ViewLayer* child = FirstChild(); child; child = NextChild()) {
                count++;
                if (deep) {
                        count += child->CountChildren(deep);
                }
        }
        return count;   
}

// CollectTokensForChildren
void
ViewLayer::CollectTokensForChildren(BList* tokenMap) const
{
        for (ViewLayer* child = FirstChild(); child; child = NextChild()) {
                tokenMap->AddItem((void*)child);
                child->CollectTokensForChildren(tokenMap);
        }
}

// ViewAt
ViewLayer*
ViewLayer::ViewAt(const BPoint& where, BRegion* windowContentClipping)
{
        if (!fVisible)
                return NULL;

        if (ScreenClipping(windowContentClipping).Contains(where))
                return this;

        for (ViewLayer* child = FirstChild(); child; child = NextChild()) {
                ViewLayer* layer = child->ViewAt(where, windowContentClipping);
                if (layer)
                        return layer;
        }
        return NULL;
}

// ConvertToParent
void
ViewLayer::ConvertToParent(BPoint* point) const
{
        // remove scrolling offset and convert to parent coordinate space
        point->x += fFrame.left - fScrollingOffset.x;
        point->y += fFrame.top - fScrollingOffset.y;
}

// ConvertToParent
void
ViewLayer::ConvertToParent(BRect* rect) const
{
        // remove scrolling offset and convert to parent coordinate space
        rect->OffsetBy(fFrame.left - fScrollingOffset.x,
                                   fFrame.top - fScrollingOffset.y);
}

// ConvertToParent
void
ViewLayer::ConvertToParent(BRegion* region) const
{
        // remove scrolling offset and convert to parent coordinate space
        region->OffsetBy(fFrame.left - fScrollingOffset.x,
                                         fFrame.top - fScrollingOffset.y);
}

// ConvertFromParent
void
ViewLayer::ConvertFromParent(BPoint* point) const
{
        // remove scrolling offset and convert to parent coordinate space
        point->x += fScrollingOffset.x - fFrame.left;
        point->y += fScrollingOffset.y - fFrame.top;
}

// ConvertFromParent
void
ViewLayer::ConvertFromParent(BRect* rect) const
{
        // remove scrolling offset and convert to parent coordinate space
        rect->OffsetBy(fScrollingOffset.x - fFrame.left,
                                   fScrollingOffset.y - fFrame.top);
}

// ConvertFromParent
void
ViewLayer::ConvertFromParent(BRegion* region) const
{
        // remove scrolling offset and convert to parent coordinate space
        region->OffsetBy(fScrollingOffset.x - fFrame.left,
                                         fScrollingOffset.y - fFrame.top);
}

// ConvertToTop
void
ViewLayer::ConvertToTop(BPoint* point) const
{
        ConvertToParent(point);

        if (fParent)
                fParent->ConvertToTop(point);
}

// ConvertToTop
void
ViewLayer::ConvertToTop(BRect* rect) const
{
        ConvertToParent(rect);

        if (fParent)
                fParent->ConvertToTop(rect);
}

// ConvertToTop
void
ViewLayer::ConvertToTop(BRegion* region) const
{
        ConvertToParent(region);

        if (fParent)
                fParent->ConvertToTop(region);
}

// ConvertFromTop
void
ViewLayer::ConvertFromTop(BPoint* point) const
{
        ConvertFromParent(point);

        if (fParent)
                fParent->ConvertFromTop(point);
}

// ConvertFromTop
void
ViewLayer::ConvertFromTop(BRect* rect) const
{
        ConvertFromParent(rect);

        if (fParent)
                fParent->ConvertFromTop(rect);
}

// ConvertFromTop
void
ViewLayer::ConvertFromTop(BRegion* region) const
{
        ConvertFromParent(region);

        if (fParent)
                fParent->ConvertFromTop(region);
}

// SetName
void
ViewLayer::SetName(const char* string)
{
        fName.SetTo(string);
}

// #pragma mark -

// MoveBy
void
ViewLayer::MoveBy(int32 x, int32 y, BRegion* dirtyRegion)
{
        if (x == 0 && y == 0)
                return;

        fFrame.OffsetBy(x, y);

        // to move on screen, we must not be hidden and we must have a parent
        if (fVisible && fParent && dirtyRegion) {
#if 0
// based on redraw on new location
                // the place were we are now visible
                BRect newVisibleBounds = Bounds();
                // we can use the frame of the old
                // local clipping to see which parts need invalidation
                BRect oldVisibleBounds(Bounds());
                oldVisibleBounds.OffsetBy(-x, -y);
                ConvertToTop(&oldVisibleBounds);

                ConvertToVisibleInTopView(&newVisibleBounds);

                dirtyRegion->Include(oldVisibleBounds);
                // newVisibleBounds already is in screen coords
                dirtyRegion->Include(newVisibleBounds);
#else
// blitting version, invalidates
// old contents
                BRect oldVisibleBounds(Bounds());
                oldVisibleBounds.OffsetBy(-x, -y);
                ConvertToTop(&oldVisibleBounds);

                BRect newVisibleBounds(Bounds());
                // NOTE: using ConvertToVisibleInTopView()
                // instead of ConvertToTop()! see below
                ConvertToVisibleInTopView(&newVisibleBounds);

                newVisibleBounds.OffsetBy(-x, -y);

                // clipping oldVisibleBounds to newVisibleBounds
                // makes sure we don't copy parts hidden under
                // parent views
                BRegion copyRegion(oldVisibleBounds & newVisibleBounds);
                fWindow->CopyContents(&copyRegion, x, y);

                BRegion dirty(oldVisibleBounds);
                newVisibleBounds.OffsetBy(x, y);
                dirty.Exclude(newVisibleBounds);
                dirtyRegion->Include(&dirty);
#endif
        }

        if (!fParent) {
                // the top view's screen clipping does not change,
                // because no parts are clipped away from parent
                // views
                _MoveScreenClipping(x, y, true);
        } else {
                // parts might have been revealed from underneath
                // the parent, or might now be hidden underneath
                // the parent, this is taken care of when building
                // the screen clipping
                InvalidateScreenClipping(true);
        }
}

// ResizeBy
void
ViewLayer::ResizeBy(int32 x, int32 y, BRegion* dirtyRegion)
{
        if (x == 0 && y == 0)
                return;

        fFrame.right += x;
        fFrame.bottom += y;

        if (fVisible && dirtyRegion) {
                BRect oldBounds(Bounds());
                oldBounds.right -= x;
                oldBounds.bottom -= y;

                BRegion dirty(Bounds());
                dirty.Include(oldBounds);

                if (!(fFlags & B_FULL_UPDATE_ON_RESIZE)) {
                        // the dirty region is just the difference of
                        // old and new bounds
                        dirty.Exclude(oldBounds & Bounds());
                }

                InvalidateScreenClipping(true);

                if (dirty.CountRects() > 0) {
                        // exclude children, they are expected to
                        // include their own dirty regions in ParentResized()
                        for (ViewLayer* child = FirstChild(); child; child = NextChild()) {
                                if (child->IsVisible()) {
                                        BRect previousChildVisible(child->Frame() & oldBounds & Bounds());
                                        if (dirty.Frame().Intersects(previousChildVisible)) {
                                                dirty.Exclude(previousChildVisible);
                                        }
                                }
                        }

                        ConvertToTop(&dirty);
                        dirtyRegion->Include(&dirty);
                }
        }

        // layout the children
        for (ViewLayer* child = FirstChild(); child; child = NextChild())
                child->ParentResized(x, y, dirtyRegion);

        // at this point, children are at their new locations,
        // so we can rebuild the clipping
        // TODO: when the implementation of Hide() and Show() is
        // complete, see if this should be avoided
        RebuildClipping(false);
}

// ParentResized
void
ViewLayer::ParentResized(int32 x, int32 y, BRegion* dirtyRegion)
{
        uint16 rm = fResizeMode & 0x0000FFFF;
        BRect newFrame = fFrame;

        // follow with left side
        if ((rm & 0x0F00U) == _VIEW_RIGHT_ << 8)
                newFrame.left += x;
        else if ((rm & 0x0F00U) == _VIEW_CENTER_ << 8)
                newFrame.left += x / 2;

        // follow with right side
        if ((rm & 0x000FU) == _VIEW_RIGHT_)
                newFrame.right += x;
        else if ((rm & 0x000FU) == _VIEW_CENTER_)
                newFrame.right += x / 2;

        // follow with top side
        if ((rm & 0xF000U) == _VIEW_BOTTOM_ << 12)
                newFrame.top += y;
        else if ((rm & 0xF000U) == _VIEW_CENTER_ << 12)
                newFrame.top += y / 2;

        // follow with bottom side
        if ((rm & 0x00F0U) == _VIEW_BOTTOM_ << 4)
                newFrame.bottom += y;
        else if ((rm & 0x00F0U) == _VIEW_CENTER_ << 4)
                newFrame.bottom += y / 2;

        if (newFrame != fFrame) {
                // careful, MoveBy will change fFrame
                int32 widthDiff = (int32)(newFrame.Width() - fFrame.Width());
                int32 heightDiff = (int32)(newFrame.Height() - fFrame.Height());

                MoveBy(newFrame.left - fFrame.left,
                           newFrame.top - fFrame.top, dirtyRegion);

                ResizeBy(widthDiff, heightDiff, dirtyRegion);
        }
}

// ScrollBy
void
ViewLayer::ScrollBy(int32 x, int32 y, BRegion* dirtyRegion)
{
        // blitting version, invalidates
        // old contents

        // remember old bounds for tracking dirty region
        BRect oldBounds(Bounds());
        // find the area of the view that can be scrolled,
        // contents are shifted in the opposite direction from scrolling
        BRect stillVisibleBounds(oldBounds);
        stillVisibleBounds.OffsetBy(x, y);

        // NOTE: using ConvertToVisibleInTopView()
        // instead of ConvertToTop(), this makes
        // sure we don't try to move or invalidate an
        // area hidden underneath the parent view
        ConvertToVisibleInTopView(&oldBounds);
        ConvertToVisibleInTopView(&stillVisibleBounds);

        fScrollingOffset.x += x;
        fScrollingOffset.y += y;

        // do the blit, this will make sure
        // that other more complex dirty regions
        // are taken care of
        BRegion copyRegion(stillVisibleBounds);
        fWindow->CopyContents(&copyRegion, -x, -y);

        // find the dirty region as far as we are
        // concerned
        BRegion dirty(oldBounds);
        stillVisibleBounds.OffsetBy(-x, -y);
        dirty.Exclude(stillVisibleBounds);
        dirtyRegion->Include(&dirty);

        // the screen clipping of this view and it's
        // childs is no longer valid
        InvalidateScreenClipping(true);
        RebuildClipping(false);
}

// #pragma mark -

// Draw
void
ViewLayer::Draw(DrawingEngine* drawingEngine, BRegion* effectiveClipping,
                                BRegion* windowContentClipping, bool deep)
{
        // we can only draw within our own area
        BRegion redraw(ScreenClipping(windowContentClipping));
        // add the current clipping
        redraw.IntersectWith(effectiveClipping);

        // fill visible region with white
        drawingEngine->FillRegion(&redraw, (rgb_color){ 255, 255, 255, 255 });

        // let children draw
        if (deep) {
                // before passing the clipping on to children, exclude our
                // own region from the available clipping
                effectiveClipping->Exclude(&ScreenClipping(windowContentClipping));

                for (ViewLayer* child = FirstChild(); child; child = NextChild()) {
                        child->Draw(drawingEngine, effectiveClipping,
                                                windowContentClipping, deep);
                }
        }
}

// ClientDraw
void
ViewLayer::ClientDraw(DrawingEngine* drawingEngine, BRegion* effectiveClipping)
{
        BRect b(Bounds());
        b.OffsetTo(0.0, 0.0);
        ConvertToTop(&b);

        if (drawingEngine->Lock()) {
                drawingEngine->ConstrainClipping(effectiveClipping);

                // draw a frame with the view color
                drawingEngine->StrokeRect(b, fViewColor);
                b.InsetBy(1, 1);
                drawingEngine->StrokeRect(b, fViewColor);
                b.InsetBy(1, 1);
                drawingEngine->StrokeRect(b, fViewColor);
                b.InsetBy(1, 1);
                drawingEngine->StrokeLine(b.LeftTop(), b.RightBottom(), fViewColor);

                drawingEngine->Unlock();
        }
}

// #pragma mark -

// SetHidden
void
ViewLayer::SetHidden(bool hidden)
{
        // TODO: test...

        if (fHidden != hidden) {
                fHidden = hidden;

                // recurse into children and update their visible flag
                if (fParent) {
                        bool olfVisible = fVisible;
                        UpdateVisibleDeep(fParent->IsVisible());
                        if (olfVisible != fVisible) {
                                // include or exclude us from the parent area
                                fParent->RebuildClipping(false);
                                if (fWindow) {
                                        // trigger a redraw
                                        BRect clippedBounds = Bounds();
                                        ConvertToVisibleInTopView(&clippedBounds);
                                        BRegion dirty(clippedBounds);
                                        fWindow->MarkContentDirty(&dirty);
                                }
                        }
                } else {
                        UpdateVisibleDeep(true);
                }
        }
}

// IsHidden
bool
ViewLayer::IsHidden() const
{
        return fHidden;
}

// UpdateVisibleDeep
void
ViewLayer::UpdateVisibleDeep(bool parentVisible)
{
        fVisible = parentVisible && !fHidden;
        for (ViewLayer* child = FirstChild(); child; child = NextChild())
                child->UpdateVisibleDeep(fVisible);
}

// PrintToStream
void
ViewLayer::PrintToStream() const
{
}

// RebuildClipping
void
ViewLayer::RebuildClipping(bool deep)
{
        // the clipping spans over the bounds area
        fLocalClipping.Set(Bounds());

        // exclude all childs from the clipping
        for (ViewLayer* child = FirstChild(); child; child = NextChild()) {
                if (child->IsVisible())
                        fLocalClipping.Exclude(child->Frame());

                if (deep)
                        child->RebuildClipping(deep);
        }

        fScreenClippingValid = false;
}

// ScreenClipping
BRegion&
ViewLayer::ScreenClipping(BRegion* windowContentClipping, bool force) const
{
        if (!fScreenClippingValid || force) {
                fScreenClipping = fLocalClipping;
                ConvertToTop(&fScreenClipping);

                // see if we parts of our bounds are hidden underneath
                // the parent, the local clipping does not account for this
                BRect clippedBounds = Bounds();
                ConvertToVisibleInTopView(&clippedBounds);
                if (clippedBounds.Width() < fScreenClipping.Frame().Width() ||
                        clippedBounds.Height() < fScreenClipping.Frame().Height()) {
                        BRegion temp(clippedBounds);
                        fScreenClipping.IntersectWith(&temp);
                }

                fScreenClipping.IntersectWith(windowContentClipping);
                fScreenClippingValid = true;
        }
        return fScreenClipping;
}

// InvalidateScreenClipping
void
ViewLayer::InvalidateScreenClipping(bool deep)
{
        fScreenClippingValid = false;
        if (deep) {
                // invalidate the childrens screen clipping as well
                for (ViewLayer* child = FirstChild(); child; child = NextChild()) {
                        child->InvalidateScreenClipping(deep);
                }
        }
}

// _MoveScreenClipping
void
ViewLayer::_MoveScreenClipping(int32 x, int32 y, bool deep)
{
        if (fScreenClippingValid)
                fScreenClipping.OffsetBy(x, y);

        if (deep) {
                // move the childrens screen clipping as well
                for (ViewLayer* child = FirstChild(); child; child = NextChild()) {
                        child->_MoveScreenClipping(x, y, deep);
                }
        }
}