#include <Application.h>
#include <WindowScreen.h>
#include <Screen.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <SupportDefs.h> // min_c() and max_c()

#ifdef DEBUGGING
#define PRINT(x) printf x
#else
#define PRINT(x)
#endif

// macros
#define set_pixel(x,y,color) (frame_buffer[x + (line_length*y)] = color)
#define get_pixel(x,y) (frame_buffer[x + (line_length*y)])

class NApplication : public BApplication {
public:
        NApplication();
        bool is_quitting; // So that the WindowScreen knows what
                     //       to do when disconnected.
private:
        bool QuitRequested();
        void ReadyToRun();
};

class NWindowScreen : public BWindowScreen {
public:
        NWindowScreen(status_t*);
private:
        void ScreenConnected(bool);
        int32 MyCode();
        static int32 Entry(void*);
        // handy stuff
        void set_frame_rate(float fps) {frame_pause = (bigtime_t)((1000 * 1000)/fps);}
        // special for demos
        enum {
                // used for star->last_draw
                        INVALID = 0x7fffffff
        };
        typedef struct {
                float init_velocity;
                float gravity;
                double cos_z_theta;
                int32 y;
                int32 x;
                int32 timeval;
                uint32 last_draw;
                int32 lx,ly;
        } particle;
        uint32 particle_count;
        particle *particle_list;
        // simple raster functions
        void draw_line(int x1, int y1, int x2, int y2, int color);
        void draw_rect(int x, int y, int w, int h, int color);
        void fill_rect(int x, int y, int w, int h, int color);
        void draw_ellipse(int cx, int cy, int wide, int deep, int color);
        void fill_ellipse(int x, int y, int xradius, int yradius, int color);
        void ellipse_points(int x, int y, int x_offset, int y_offset, int color);
        void ellipse_fill_points(int x, int y, int x_offset, int y_offset, int color);
        thread_id tid;
        sem_id sem;
        area_id area;
        uint8* save_buffer;
        uint8* frame_buffer;
        ulong line_length;
        bigtime_t frame_pause; // time between frames
        int width,height;
        int COLORS;
        bool thread_is_locked;  // small hack to allow to quit the
                                                        //      app from ScreenConnected()
};

int
main()
{
        NApplication app;
        return 0;
}

NApplication::NApplication()
      :BApplication("application/x-vnd.Prok-DemoTemplate")
{
        Run(); // see you in ReadyToRun()
}

void NApplication::ReadyToRun()
{
        PRINT(("ReadyToRun()\n"));
        status_t ret = B_ERROR;
        is_quitting = false;
        NWindowScreen *ws = new NWindowScreen(&ret);
        PRINT(("WindowScreen ctor returned. ret = %s\n", strerror(ret)));
        // exit if constructing the WindowScreen failed.
        if((ws == NULL) || (ret < B_OK))
        {
                //printf("the window screen was NULL, or there was an error\n");
                PostMessage(B_QUIT_REQUESTED);
        }
        else
                PRINT(("everything's just peachy. done with ReadyToRun().\n"));
}

bool NApplication::QuitRequested()
{
        PRINT(("QuitRequested()\n"));
        status_t ret;
        is_quitting = true;
        wait_for_thread(find_thread("rendering thread"), &ret); // wait for the render thread to finish 
        return true;
}

NWindowScreen::NWindowScreen(status_t *ret)
        : BWindowScreen("Example", B_8_BIT_640x480, ret), width(639), height(479), COLORS(256)
{
        PRINT(("WindowScreen ctor.\n"));
        thread_is_locked = true;
        tid = 0;
        if(*ret == B_OK)
        {
                PRINT(("creating blocking sem and save_buffer area.\n"));
                // this semaphore controls the access to the WindowScreen
                sem = create_sem(0,"WindowScreen Access");
                // this area is used to save the whole framebuffer when
                //       switching workspaces. (better than malloc()).
                area = create_area("save", (void**)&save_buffer, B_ANY_ADDRESS, 640*480, B_NO_LOCK, B_READ_AREA|B_WRITE_AREA);
                // exit if an error occured.
                if((sem < B_OK) || (area < B_OK))
                {
                        PRINT(("create_area() or create_sem() failed\n"));
                        *ret = B_ERROR;
                }
                else
                {
                        PRINT(("calling Show().\n"));
                        Show(); // let's go. See you in ScreenConnected.
                }
        }
        else
        {
                PRINT(("BWindowScreen base class ctor returned failure\n"));
                be_app->PostMessage(B_QUIT_REQUESTED);
        }
        // set the frame rate
        set_frame_rate(30.);
}


void
NWindowScreen::ScreenConnected(bool connected)
{
        PRINT(("ScreenConnected()\n"));
        fflush(stdout);
        if(connected)
        {
                if(SetSpace(B_8_BIT_640x480) < B_OK)
                {
                        //SetFrameBuffer(640, 480);
                        PRINT(("SetSpace() failed\n"));
                        // properly set the framebuffer. exit if an error occurs.
                        be_app->PostMessage(B_QUIT_REQUESTED);
                        return;
                }
                // get the framebuffer-related info, each time the
                // WindowScreen is connected (multiple monitor)
                frame_buffer = (uint8*)(CardInfo()->frame_buffer);
                line_length = FrameBufferInfo()->bytes_per_row;
                if(tid == 0)
                {
                        // clean the framebuffer
                        PRINT(("zeroing the framebuffer\n"));
                        memset(frame_buffer,0,480*line_length);
                        // spawn the rendering thread. exit if an error occurs.
                        PRINT(("spawning the render thread.\n"));
                        tid = spawn_thread(Entry,"rendering thread", B_URGENT_DISPLAY_PRIORITY,this);
                        if(resume_thread(tid) < B_OK)
                        {
                                be_app->PostMessage(B_QUIT_REQUESTED);
                                return;
                        }
                }
                else
                {
                        for(int y=0;y<480;y++)
                        {
                                // restore the framebuffer when switching back from
                                // another workspace.
                memcpy(frame_buffer+y*line_length,save_buffer+640*y,640);
            }
                }
                // set our color list.
                rgb_color palette[256];
                rgb_color c1;
                for(int i=0,j=0;i<256;i++,j++)
                {
                        if(i<64)
                        {
                                c1.red = j*4; // greys
                                c1.green = j*4;
                                c1.blue = j*4;
                                c1.alpha = 255;
                        }
                        if((i>=64) && (i<128))
                        {
                                c1.red = j*4; // reds
                                c1.green = 0;
                                c1.blue = 0;
                                c1.alpha = 255;
                        }
                        if((i>=128) && (i<192))
                        {
                                c1.red = 0; // greens
                                c1.green = j*4;
                                c1.blue = 0;
                                c1.alpha = 255;
                        }
                        if((i>=192) && (i<256))
                        {
                                c1.red = 0; // blues
                                c1.green = 0;
                                c1.blue = j*4;
                                c1.alpha = 255;
                        }
                        if(j == 64)
                                j=0;
                        palette[i]=c1;
                }
                SetColorList(palette);
                
                // allow the rendering thread to run.
                thread_is_locked = false;
                release_sem(sem);
        }
        else /* !connected */
        {
                // block the rendering thread.
                if(!thread_is_locked)
                {
                        acquire_sem(sem);
                        thread_is_locked = true;
                }
                // kill the rendering and clean up when quitting
                if((((NApplication*)be_app)->is_quitting))
                {
                        status_t ret;
                        kill_thread(tid);
                        wait_for_thread(tid,&ret);
                        delete_sem(sem);
                        delete_area(area);
                        free(particle_list);
                }
                else
                {
                        // set the color list black so that the screen doesn't seem
                        // to freeze while saving the framebuffer
                        rgb_color c={0,0,0,255};
                        rgb_color palette[256];
                        // build the palette
                        for(int i=0;i<256;i++)
                                palette[i] = c;
                        // set the palette
                        SetColorList(palette);
                        // save the framebuffer
                        for(int y=0;y<480;y++)
                                memcpy(save_buffer+640*y,frame_buffer+y*line_length,640);
                }
        }
}


int32
NWindowScreen::Entry(void* p)
{
   return ((NWindowScreen*)p)->MyCode();
}


int32
NWindowScreen::MyCode()
{
        bigtime_t trgt = system_time() + frame_pause;
        srandom(system_time());
        // beforehand stuff
        particle_count = 1024*2;
        particle_list = (particle *)malloc(sizeof(particle)*particle_count);
        for (uint32 i=0; i<particle_count; i++) {
                uint32 rand_max = 0xffffffff;           
                particle_list[i].init_velocity = -((double)((rand_max>>1)+(random()%(rand_max>>1)))/rand_max)*3.333; // magic number
                particle_list[i].gravity = -(((double)((rand_max>>1)+(random()%(rand_max>>1)))/rand_max))*0.599; // more magic
                
                // make the particle initialy invisible and fixed, but at a random moment in time
                particle_list[i].lx = 0;
                particle_list[i].ly = 0;
                particle_list[i].last_draw = INVALID;
                particle_list[i].timeval = random() & 64;
                particle_list[i].x = 0; // this gets figured out at drawtime
                particle_list[i].y = 0; // same here
                particle_list[i].cos_z_theta = cos(random() % 360); // grab an angle
        }
        
        
        // the loop o' fun
        while (!(((NApplication*)be_app)->is_quitting)) {
                // try to sync with the vertical retrace
                if (BScreen(this).WaitForRetrace() != B_OK) {
                        // snoze for a bit so that other threads can be happy. 
                        // We are realtime priority you know
                        if (system_time() < trgt)
                                snooze(trgt - system_time());
                        trgt = system_time() + frame_pause;
                }
                
                // gain access to the framebuffer before writing to it.
                acquire_sem(sem); // block until we're allowed to own the framebuffer
                
                ///////////////////////////////
                // do neat stuff here //
                //////////////////////////////
                PRINT(("rendering a frame.\n"));
        
                
                // eye candy VII - particles! - my own cookin
                int32 x, y, cx,cy;
                set_frame_rate(60.); // woo. ntsc
                // calculate the center
                cx = width/2;
                cy = height/2;
                
                // palette test
                //set_frame_rate(0.1);
                //for(int i=0;i<256;i++)
                //      draw_line(i,0,i,height, i);
                
                PRINT(("Starting particle drawing loop\n"));
                particle *s = particle_list;
                for (uint32 i=0; i<particle_count; i++) {
                        PRINT(("drawing particle %d\r", i));
                        
                        // save the old position
                        s->lx = s->x;
                        s->ly = s->y;
                        
                        PRINT(("cx=%d, cy=%d\n", cx,cy));
                                                        
                        // move the particle                    
                        // find y and x
                        // (s->gravity/2)*(s->timeval*s->timeval) * 1.85 is magic
                        y = s->y = (int32)(cy + (int32)((s->gravity/2)*(s->timeval*s->timeval)*1.94) + ((s->init_velocity - (s->gravity*s->timeval)) * s->timeval));
                        x = s->x = (int32)(cx + (int32)(s->timeval * s->cos_z_theta)); // 3d rotation
                
                        // interate timeval
                        s->timeval++;
                
                        // sanity check
                        if(x <= 0)
                                goto erase_and_reset;
                        if(x > width)
                                goto erase_and_reset;
                        if(y < 0)
                                goto erase; // invisible + erase last position
                        if(y > height)
                                goto erase_and_reset;
                                        
                        // erase the previous position, if necessary
                        if (s->last_draw != INVALID)
                                set_pixel(s->lx,s->ly,0);
                        
                        // if it's visible, then draw it.
                        set_pixel(s->x,s->y, 169);
                        s->last_draw = 1;
                        goto loop;
                        
                        erase_and_reset:
                        if((s->lx <= width) && (s->lx >= 0) && (s->ly <= height) && (s->ly >= 0))
                                set_pixel(s->lx, s->ly,0);
                        s->x = 0;
                        s->y = 0;
                        s->lx = 0;
                        s->ly = 0;
                        s->timeval = 0;
                        s->last_draw = INVALID;
                        goto loop;
                        
                        erase:
                        // erase it.
                        if(s->last_draw != INVALID)
                                set_pixel(s->lx, s->ly,0);
                        s->lx = s->x;
                        s->ly = s->y;
                        s->last_draw = INVALID;
                        loop:
                                s++;
                        //printf("end draw loop\n");
                }
                PRINT(("frame done\n"));
                
                //////////////////////////////////
                // stop doing neat stuff //
                /////////////////////////////////
                
                // release the semaphore while waiting. gotta release it
                // at some point or nasty things will happen!
                release_sem(sem);
                // loop for another frame!
        }
        return B_OK;
}

//////////////////////////////
// Misc - a place for demos to put their convenience functions
//////////////////////////////


//////////////////////////////
// My Silly Raster Lib 
//////////////////////////////

/*

        Functions:
void draw_line(int x1, int y1, int x2, int y2, int color);
void draw_rect(int x, int y, int w, int h, int color);
void fill_rect(int x, int y, int w, int h, int color);
void draw_ellipse(int x, int y, int xradius, int yradius, int color);
void fill_ellipse(int x, int y, int xradius, int yradius, int color);

*/

void
NWindowScreen::draw_line(int x1, int y1, int x2, int y2, int color)
{
        // Simple Bresenham's line drawing algorithm
        int d,x,y,ax,ay,sx,sy,dx,dy;
        
#define ABS(x) (((x)<0) ? -(x) : (x))
#define SGN(x) (((x)<0) ? -1 : 1)

        dx=x2-x1; ax=ABS(dx)<<1; sx=SGN(dx);
        dy=y2-y1; ay=ABS(dy)<<1; sy=SGN(dy);
        
        x=x1;
        y=y1;
        if(ax>ay)
        {
                d=ay-(ax>>1);
                for(;;)
                {
                        set_pixel(x,y,color);
                        if(x==x2) return;
                        if(d>=0)
                        {
                                y+=sy;
                                d-=ax;
                        }
                        x+=sx;
                        d+=ay;
                }
        }
        else
        {
                d=ax-(ay>>1);
                for(;;)
                {
                        set_pixel(x,y,color);
                        if(y==y2) return;
                        if(d>=0)
                        {
                                x+=sx;
                                d-=ay;
                        }
                        y+=sy;
                        d+=ax;
                }
        }
}


void
NWindowScreen::draw_rect(int x, int y, int w, int h, int color)
{
        draw_line(x,y,x+w,y,color);
        draw_line(x,y,x,y+h,color);
        draw_line(x,y+h,x+w,y+h,color);
        draw_line(x+w,y,x+w,y+h,color);
}


void
NWindowScreen::fill_rect(int x, int y, int w, int h, int color)
{
        for (int i = 0; i < w; i++) {
                for (int j = 0; j < h; j++) {
                        set_pixel(i, j, color);
                }
        }
}


void
NWindowScreen::draw_ellipse(int cx, int cy, int wide, int deep, int color)
{
        // if we're asked to draw a really small ellipse, put a single pixel in the buffer
        // and bail
        if((wide < 1) || (deep < 1))
        {
                set_pixel(cx,cy,color);
                return;
        }
        
        // MidPoint Ellipse algorithm. 
        // page 90 of Computer Graphics Principles and Practice 2nd edition (I highly recommend this book)
        int16 x, y;
        int16 wide_squared, deep_squared;
        double d;

        x = 0;  
        y = deep;
        wide_squared = wide * wide;
        deep_squared = deep * deep;
        d = deep_squared - (wide_squared*deep) + (wide_squared/4);
        
        ellipse_points(x, y, cx, cy, color);
        while((wide_squared*(y - 0.5)) > (deep_squared*(x + 1)))
        {
                if(d < 0)
                        d += deep_squared*(2*x + 3);
                else
                {
                        d += deep_squared*(2*x + 3) + wide_squared*(-2*y + 2);
                        y--;
                }
                x++;
                ellipse_points(x, y, cx, cy, color);
        }
        
        d = deep_squared*((x+0.5)*(x+0.5)) + wide_squared*((y-1)*(y-1)) - deep_squared*wide_squared;
        while(y > 0)
        {
                if(d < 0)
                {
                        d += deep_squared*(2*x + 2) + wide_squared*(-2*y + 3);
                        x++;
                }
                else
                        d += wide_squared*(-2*y + 3);
                y--;
                ellipse_points(x, y, cx, cy, color);
        }
}


void
NWindowScreen::fill_ellipse(int cx, int cy, int wide, int deep, int color)
{
        // if we're asked to draw a really small ellipse, put a single pixel in the buffer
        // and bail
        if((wide < 1) || (deep < 1))
        {
                set_pixel(cx,cy,color);
                return;
        }
        
        // MidPoint Ellipse algorithm. 
        // page 90 of Computer Graphics Principles and Practice 2nd edition (I highly recommend this book)
        int16 x, y;
        int16 wide_squared, deep_squared;
        double d;

        x = 0;  
        y = deep;
        wide_squared = wide * wide;
        deep_squared = deep * deep;
        d = deep_squared - (wide_squared*deep) + (wide_squared/4);
        
        ellipse_fill_points(x, y, cx, cy, color);
        while((wide_squared*(y - 0.5)) > (deep_squared*(x + 1)))
        {
                if(d < 0)
                        d += deep_squared*(2*x + 3);
                else
                {
                        d += deep_squared*(2*x + 3) + wide_squared*(-2*y + 2);
                        y--;
                }
                x++;
                ellipse_fill_points(x, y, cx, cy, color);
        }
        
        d = deep_squared*((x+0.5)*(x+0.5)) + wide_squared*((y-1)*(y-1)) - deep_squared*wide_squared;
        while(y > 0)
        {
                if(d < 0)
                {
                        d += deep_squared*(2*x + 2) + wide_squared*(-2*y + 3);
                        x++;
                }
                else
                        d += wide_squared*(-2*y + 3);
                y--;
                ellipse_fill_points(x, y, cx, cy, color);
        }
}


void
NWindowScreen::ellipse_points(int x, int y, int x_offset, int y_offset, int color)
{
        // fill four pixels for every iteration in draw_ellipse
        
        // the x_offset and y_offset values are needed since the midpoint ellipse algorithm 
        // assumes the midpoint to be at the origin
        // do a sanity check before each set_pixel, that way we clip to the edges
        
        int xCoord, yCoord;

        xCoord = x_offset + x;
        yCoord = y_offset + y;
        if((xCoord > 0) && (yCoord > 0) && (xCoord < width) && (yCoord < height))
                set_pixel(xCoord,yCoord,color);
        xCoord = x_offset - x;
        if((xCoord > 0) && (yCoord > 0) && (xCoord < width) && (yCoord < height))
                set_pixel(xCoord,yCoord,color);
        xCoord = x_offset + x;
        yCoord = y_offset - y;
        if((xCoord > 0) && (yCoord > 0) && (xCoord < width) && (yCoord < height))
                set_pixel(xCoord,yCoord,color);
        xCoord = x_offset - x;
        if((xCoord > 0) && (yCoord > 0) && (xCoord < width) && (yCoord < height))
                set_pixel(xCoord,yCoord,color);
}


void
NWindowScreen::ellipse_fill_points(int x, int y, int x_offset, int y_offset, int color)
{
        // put lines between two pixels twice. once for y positive, the other for y negative (symmetry)
        // for every iteration in fill_ellipse
        
        // the x_offset and y_offset values are needed since the midpoint ellipse algorithm 
        // assumes the midpoint to be at the origin
        // do a sanity check before each set_pixel, that way we clip to the edges
        
        int xCoord1, yCoord1;
        int xCoord2, yCoord2;

        xCoord1 = x_offset - x;
        yCoord1 = y_offset + y;
        xCoord2 = x_offset + x;
        yCoord2 = y_offset + y;
        if((xCoord1 > 0) && (yCoord1 > 0) && (xCoord1 < width) && (yCoord1 < height))   
                if((xCoord2 > 0) && (yCoord2 > 0) && (xCoord2 < width) && (yCoord2 < height))
                        draw_line(xCoord1,yCoord1,xCoord2,yCoord2,color);
        
        xCoord1 = x_offset - x;
        yCoord1 = y_offset - y;
        xCoord2 = x_offset + x;
        yCoord2 = y_offset - y;
        if((xCoord1 > 0) && (yCoord1 > 0) && (xCoord1 < width) && (yCoord1 < height))   
                if((xCoord2 > 0) && (yCoord2 > 0) && (xCoord2 < width) && (yCoord2 < height))
                        draw_line(xCoord1,yCoord1,xCoord2,yCoord2,color);

}