#include <math.h>
#include <SDL.h>
#include "engine.h"
#include "base.h"
#include "shape.h"
#include "texture.h"
#include "font.h"

#define ENTER bool flag = Enter()
#define LEAVE Leave(flag)

mogltk::fillwalker::fillwalker() {
}

mogltk::fillwalker::~fillwalker() {
}

void mogltk::fillwalker::step(int x, int y) {
}

mogltk::fill::fill() : header(0) {
}

mogltk::fill::~fill() {
    if (header)
	delete header;
}

void mogltk::fill::walk(fillwalker * w) {
    header->walk(w);
}

void mogltk::fill::insert(int x, int y) {
    if (!header) {
	new sline(y, this);
    }
    header->insert(x, y);
}

mogltk::fill::sline::sline(int _y, fill * _header) : y(_y), header(_header), pheader(0) {
    if (!header->header) {
	header->header = this;
    } else {
	if (header->header->y > y) {
	    next = header->header;
	    header->header = this;
	} else {
	    sline * p;
	    for (p = header->header; p->next; p = p->next) {
		if (p->next->y > y) {
		    next = p->next;
		    p->next = this;
		    return;
		}
	    }
	    p->next = this;
	    next = 0;
	}
    }
}

mogltk::fill::sline::~sline() {
    if (pheader)
	delete pheader;
    if (next)
	delete next;
}

int mogltk::fill::sline::GetY() const {
    return y;
}

void mogltk::fill::sline::insert(int ax, int ay) {
    sline * f;
    
    if (ay == y) {
	if (!pheader)
	    new point(ax, this);
	else if (!pheader->look(ax))
	    new point(ax, this);
    } else {
	f = header->header->look(ay);

	if (!f) {
	    f = new sline(ay, header);
	}
	
	f->insert(ax, ay);
    }
}

void mogltk::fill::sline::walk(fillwalker * w) {
    if (pheader)
	pheader->walk(w);
    if (next)
	next->walk(w);
}

mogltk::fill::sline::point::point(int _x, sline * _header) : x(_x), header(_header) {
    if (!header->pheader) {
	header->pheader = this;
    } else {
        if (header->pheader->x > x) {
	    next = header->pheader;
	    header->pheader = this;
	} else {
	    point * p;
	    for (p = header->pheader; p->next; p = p->next) {
		if (p->next->x > x) {
		    next = p->next;
		    p->next = this;
		    return;
		}
	    }
	    p->next = this;
	    next = 0;
	}
    }
}

mogltk::fill::sline::point::~point() {
    if (next)
	delete next;
}

int mogltk::fill::sline::point::GetX() const {
    return x;
}

int mogltk::fill::sline::point::GetY() const {
    return header->GetY();
}

void mogltk::fill::sline::point::walk(fillwalker * w) {
    w->step(GetX(), GetY());
    if (next)
	next->walk(w);
}

mogltk::fill::sline::point * mogltk::fill::sline::point::look(int _x) {
    if (x > _x)
	return 0;
    
    if (x == _x)
	return this;
    
    if (!next)
	return 0;

    return next->look(_x);
}

mogltk::fill::sline * mogltk::fill::sline::look(int _y) {
    if (y > _y)
	return 0;
    
    if (y == _y)
	return this;

    if (!next)
	return 0;

    return next->look(_y);
}

void mogltk::shape::box(int x1, int y1, int x2, int y2, ColorP c) {
    ENTER;
    
    SDL_Rect rect;
    
    rect.x = x1; rect.y = y1; rect.w = x2 - x1 + 1; rect.h = y2 - y1 + 1;
    SDL_FillRect(mogltk::engine::base_o->getsurface(), &rect, c.toSDL());
    
    LEAVE;
}

void mogltk::shape::hline(int x1, int x2, int y, ColorP c) {
    box(x1, y, x2, y, c);
}

void mogltk::shape::hline3d(int x1, int x2, int y, ColorP shade1, ColorP shade2, bool bevel) {
    ENTER;
    
    if (!bevel) {
	hline(x1, x2, y, shade2);
	hline(x1, x2, y + 1, shade1);
    } else {
	hline(x1, x2, y, shade1);
	hline(x1, x2, y + 1, shade2);
    }
    
    LEAVE;
}

void mogltk::shape::vline(int x, int y1, int y2, ColorP c) {
    box(x, y1, x, y2, c);
}

void mogltk::shape::vline3d(int x, int y1, int y2, ColorP shade1, ColorP shade2, bool bevel) {
    ENTER;
    
    if (!bevel) {
	vline(x, y1, y2, shade2);
	vline(x + 1, y1, y2, shade1);
    } else {
	vline(x, y1, y2, shade1);
	vline(x + 1, y1, y2, shade2);
    }
    
    LEAVE;
}

void mogltk::shape::pixel(int x, int y, ColorP c) {
    ENTER;
    
    SDL_Surface * surface = mogltk::engine::base_o->getsurface();
    int bpp = surface->format->BytesPerPixel;
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
    Uint32 pixel = c.toSDL();

    switch(bpp) {
    case 1:
        *p = pixel;
        break;

    case 2:
        *(Uint16 *)p = pixel;
        break;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
            p[0] = (pixel >> 16) & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = pixel & 0xff;
        } else {
            p[0] = pixel & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = (pixel >> 16) & 0xff;
        }
        break;

    case 4:
        *(Uint32 *)p = pixel;
        break;
    }

    LEAVE;
}

void mogltk::shape::circle(int x0, int y0, int r, ColorP c) {
    ENTER;
    
    int x = 0;
    int y = r - 1;
    int d = 3 - 2 * r;
    int dI = 10 - 4 * r;
    int rI = 6;
    
    while (x <= y) {
	pixel(x0 + x, y0 + y, c);
	pixel(x0 - x, y0 + y, c);
	pixel(x0 + x, y0 - y, c);
	pixel(x0 - x, y0 - y, c);
	pixel(x0 + y, y0 + x, c);
	pixel(x0 - y, y0 + x, c);
	pixel(x0 + y, y0 - x, c);
	pixel(x0 - y, y0 - x, c);
	if (d >= 0) {
	    d += dI;
	    dI += 8;
	    y -= 1;
	} else {
	    d += rI;
	    dI += 4;
	}
	rI += 4;
	x += 1;
    }

    LEAVE;
}

mogltk::fill * mogltk::shape::fcircle(int x0, int y0, int r) {
    int x = 0;
    int y = r - 1;
    int d = 3 - 2 * r;
    int dI = 10 - 4 * r;
    int rI = 6;
    mogltk::fill * f = new fill();
    bool t = true;
    
    while (x <= y) {
	if (t) {
	    f->insert(x0 - x, y0 - y);
	    f->insert(x0 + x, y0 - y);
	    f->insert(x0 - x, y0 + y);
	    f->insert(x0 + x, y0 + y);
	}
	f->insert(x0 - y, y0 - x);
	f->insert(x0 + y, y0 - x);
	f->insert(x0 - y, y0 + x);
	f->insert(x0 + y, y0 + x);
	if (d >= 0) {
	    d += dI;
	    dI += 8;
	    y -= 1;
	    t = true;
	} else {
	    d += rI;
	    dI += 4;
	    t = false;
	}
	rI += 4;
	x += 1;
    }
    return f;
}

void mogltk::shape::pcircle(int x, int y, int r, ColorP c) {
    fill * f = fcircle(x, y, r);
    fdraw(f, c);
    delete f;
}

class filldrawer : public mogltk::fillwalker {
  public:
      filldrawer(mogltk::shape * _s, mogltk::ColorP _c = DOS_WHITE) : s(_s), c(_c), oldx(-1), oldy(-1) { }
      virtual ~filldrawer() { }
    virtual void step(int x, int y) {
	if (oldy != y)
	    oldx = -1;
	if (oldx == -1) {
	    oldx = x;
	} else {
	    s->hline(oldx, x, y, c);
	    oldx = -1;
	}
	oldy = y;
    }
  private:
    mogltk::shape * s;
    mogltk::ColorP c;
    int oldx, oldy;
};

void mogltk::shape::fdraw(fill * f, ColorP c) {
    ENTER;
    filldrawer * w = new filldrawer(this, c);
    f->walk(w);
    delete w;
    LEAVE;
}

void mogltk::shape::arc(int x0, int y0, int r, double a1, double a2, ColorP c) {
    ENTER;
    
    int x = 0;
    int y = r - 1;
    int d = 3 - 2 * r;
    int dI = 10 - 4 * r;
    int rI = 6;
    
    while (x <= y) {
	pixel(x0 + y, y0 - x, c); // 1
	pixel(x0 + x, y0 - y, c); // 2
	pixel(x0 - x, y0 - y, c); // 3
	pixel(x0 - y, y0 - x, c); // 4
	pixel(x0 - y, y0 + x, c); // 5
	pixel(x0 - x, y0 + y, c); // 6
	pixel(x0 + x, y0 + y, c); // 7
	pixel(x0 + y, y0 + x, c); // 8
    
	if (d >= 0) {
	    d += dI;
	    dI += 8;
	    y -= 1;
	} else {
	    d += rI;
	    dI += 4;
	}
	rI += 4;
	x += 1;
    }

    LEAVE;
}

void mogltk::shape::arc(int x0, int y0, int r, int x1, int y1, int x2, int y2, ColorP c) {
}

void mogltk::shape::obox(int x1, int y1, int x2, int y2, ColorP c) {
    ENTER;

    hline(x1, x2, y1, c);
    hline(x1, x2, y2, c);
    vline(x1, y1, y2, c);
    vline(x2, y1, y2, c);

    LEAVE;
}

void mogltk::shape::box3d(int x1, int y1, int x2, int y2, ColorP face, ColorP shade1, ColorP shade2, int depth, bool bevel) {
    ENTER;

    int i;

    for (i = 0; i < depth; i++) {
	hline(x1 + i, x2 - i, y1 + i, bevel ? shade2 : shade1);
	vline(x1 + i, y1 + i, y2 - i, bevel ? shade2 : shade1);
    }

    for (i = 0; i < depth; i++) {
	hline(x1 + i, x2 - i, y2 - i, bevel ? shade1 : shade2);
	vline(x2 - i, y1 + i, y2 - i, bevel ? shade1 : shade2);
    }

    box(x1 + depth, y1 + depth, x2 - depth, y2 - depth, face);
    
    LEAVE;
}

void mogltk::shape::obox3d(int x1, int y1, int x2, int y2, ColorP shade1, ColorP shade2, bool bevel) {
    ENTER;
    
    if (!bevel) {
	obox(x1 + 1, y1 + 1, x2, y2, shade1);
	obox(x1, y1, x2 - 1, y2 - 1, shade2);
    } else {
	obox(x1, y1, x2 - 1, y2 - 1, shade1);
	obox(x1 + 1, y1 + 1, x2, y2, shade2);
    }
    
    LEAVE;
}

void mogltk::shape::window(int x1, int y1, int x2, int y2, const String & title,
			    ColorP titlecolor, ColorP titlebackcolor,
			    ColorP front, ColorP shade1, ColorP shade2) {
    ENTER;
    
    box3d(x1, y1, x2, y2, front, shade1, shade2);
    hline3d(x1 + 2, x2 - 2, y1 + 19, shade1, shade2, 1);
    box(x1 + 2, y1 + 2, x2 - 2, y1 + 18, titlebackcolor);
    text((x1 + x2) / 2, y1 + 2, title, titlecolor, CENTER);
    
    LEAVE;
}

void mogltk::shape::text(int x, int y, const String & text, ColorP textcolor, align_t align) {
    int tsize = SystemFont->singletextsize(text);
    switch (align) {
    case LEFT:
	SystemFont->putcursor(x, y);
	break;
    case CENTER:
	SystemFont->putcursor(x - (tsize / 2), y);
	break;
    case RIGHT:
	SystemFont->putcursor(x - tsize, y);
	break;
    }
    SystemFont->setcolor(textcolor);
    SystemFont->setshadow(0);
    SystemFont->printf(text);
}

void mogltk::shape::text3d(int x, int y, const String & atext, ColorP textcolor,
			    ColorP shade1, ColorP shade2,
			    align_t align, bool bevel) {
    ENTER;
    
    SystemFont->setwspace(1);
    if (!bevel) {
        text(x - 1, y - 1, atext, shade2, align);
        text(x + 1, y + 1, atext, shade1, align);
    } else {
	text(x - 1, y - 1, atext, shade1, align);
        text(x + 1, y + 1, atext, shade2, align);
    }
    text(x, y, atext, textcolor, align);
    SystemFont->setwspace(0);

    LEAVE;
}

void mogltk::shape::button(int x1, int y1, int x2, int y2,
			    const String & atext, bool bevel,
			    ColorP front, ColorP shade1, ColorP shade2,
			    ColorP round, ColorP textcolor,
			    ColorP tshade1, ColorP tshade2) {
    ENTER;
    
    box3d(x1, y1, x2, y2, front, shade1, shade2, 2, bevel);
    hline(x1, x2, y1 - 1, round);
    hline(x1, x2, y2 + 1, round);
    vline(x1 - 1, y1, y2, round);
    vline(x2 + 1, y1, y2, round);
    pixel(x1, y1, round);
    pixel(x1, y2, round);
    pixel(x2, y1, round);
    pixel(x2, y2, round);
    text3d((x1 + x2) / 2, (y1 + y2) / 2 - 8, atext, textcolor, tshade1, tshade2, CENTER, bevel);
    
    LEAVE;
}

bool mogltk::shape::Enter() {
    if (SDL_MUSTLOCK(mogltk::engine::base_o->getsurface())) {
	SDL_LockSurface(mogltk::engine::base_o->getsurface());
	return true;
    } else {
	return false;
    }
}

void mogltk::shape::Leave(bool locked) {
    if (locked)
	SDL_UnlockSurface(mogltk::engine::base_o->getsurface());
}