using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Text;

using allegro;
using alleggl;

public class dumbtest : AllegGL
{
    static volatile int chrono = 0;

    static TimerHandler _the_timer = new TimerHandler(the_timer);
    static void the_timer()
    {
        chrono++;
    }

    static int[] poly_coords = { 150, 400, 200, 400, 225, 425, 200, 450, 175, 450, 175, 425 };

    /* Some common colours */
    static int CYAN() { return makecol(0, 255, 255); }
    static int BLACK() { return makecol(0, 0, 0); }

    static int Main()
    {
        float rotate = 0;
        BITMAP save_bmp;
        BITMAP sub_screen, sub_screen2, vid_bitmap, mem_bitmap, vid_bitmap2,
               trans_mem_bitmap, trans_vid_bitmap, trans_vid_bitmap2,
               large_vid_bitmap, proxy_vid_bitmap, vid_pattern;
        //RLE_SPRITE rle_sprite, trans_rle_sprite;
        BITMAP rle_sprite, trans_rle_sprite;
        int keypress;
        int frame_count = 0, frame_count_time = 0;
        int x, y;
        float fps_rate = 0.0f;

        allegro_init();
        install_allegro_gl();
        install_timer();

        allegro_gl_set(AGL_DOUBLEBUFFER, 1);
        allegro_gl_set(AGL_WINDOWED, TRUE);
        allegro_gl_set(AGL_COLOR_DEPTH, 32);
        allegro_gl_set(AGL_SUGGEST, AGL_DOUBLEBUFFER | AGL_WINDOWED
                     | AGL_COLOR_DEPTH);

        if (set_gfx_mode(GFX_OPENGL, 640, 480, 0, 0) < 0)
        {
            allegro_message(string.Format("Error setting OpenGL graphics mode:\n{0}\n" +
                             "Allegro GL error : {1}\n",
                             allegro_error, allegro_gl_error));
            //exit(0);
            return -1;
        }

        /* Needed because of a bug. */
        allegro_gl_set_allegro_mode();
        allegro_gl_unset_allegro_mode();

        save_bmp = create_bitmap(640, 480);
        Debug.Assert(save_bmp != NULL);

        sub_screen = create_sub_bitmap(screen, 320, 0, 128, 96);
        sub_screen2 = create_sub_bitmap(screen, 448, 0, 128, 96);
        Debug.Assert(sub_screen != NULL);
        Debug.Assert(sub_screen2 != NULL);

        vid_bitmap = create_video_bitmap(50, 50);
        clear_to_color(vid_bitmap, makecol(255, 0, 255));
        rect(vid_bitmap, 10, 10, 39, 39, makecol(255, 255, 255));
        rectfill(vid_bitmap, 12, 12, 37, 37, makecol(255, 0, 0));
        triangle(vid_bitmap, 9, 9, 46, 3, 0, 16, makecol(0, 255, 0));

        mem_bitmap = create_bitmap(50, 50);
        //clear(mem_bitmap);
        blit(vid_bitmap, mem_bitmap, 25, 25, 10, 10, 50, 50);

        vid_pattern = create_video_bitmap(32, 32);
        clear_bitmap(vid_pattern);
        blit(vid_bitmap, vid_pattern, 0, 0, 0, 0, 32, 32);

        Debug.Write("Starting main loop\n");
        save_bitmap("dumbtest.bmp", mem_bitmap, NULL);

        rle_sprite = get_rle_sprite(mem_bitmap);

        vid_bitmap2 = create_video_bitmap(64, 64);
        clear_to_color(vid_bitmap2, makecol(255, 0, 255));
        blit(mem_bitmap, vid_bitmap2, 0, 0, 10, 10, 50, 50);

        trans_mem_bitmap = create_bitmap_ex(32, mem_bitmap.w, mem_bitmap.h);
        for (y = 0; y < mem_bitmap.h; ++y)
        {
            for (x = 0; x < mem_bitmap.w; ++x)
            {
                int col = getpixel(mem_bitmap, x, y);
                putpixel(trans_mem_bitmap, x, y, makeacol32(getr(col), getg(col), getb(col), y * 4));
            }
        }

        allegro_gl_set_video_bitmap_color_depth(32);

        trans_vid_bitmap2 = create_video_bitmap(64, 64);
        clear_bitmap(trans_vid_bitmap2);
        blit(trans_mem_bitmap, trans_vid_bitmap2, 0, 0, 10, 10, 50, 50);

        trans_vid_bitmap = create_video_bitmap(50, 50);
        clear_to_color(trans_mem_bitmap, makeacol32(255, 0, 255, 127));
        rect(trans_mem_bitmap, 10, 10, 39, 39, makeacol32(255, 255, 255, 127));
        rectfill(trans_mem_bitmap, 12, 12, 37, 37, makeacol32(255, 0, 0, 192));
        triangle(trans_mem_bitmap, 9, 9, 46, 3, 0, 16, makeacol32(0, 255, 0, 192));
        blit(trans_mem_bitmap, trans_vid_bitmap, 0, 0, 0, 0, 50, 50);

        trans_rle_sprite = get_rle_sprite(trans_mem_bitmap);

        allegro_gl_set_video_bitmap_color_depth(-1);

        large_vid_bitmap = create_video_bitmap(120, 120);
        clear_to_color(large_vid_bitmap, BLACK());
        rect(large_vid_bitmap, 0, 0, large_vid_bitmap.w - 1, large_vid_bitmap.h - 1, makecol(255, 255, 0));
        line(large_vid_bitmap, 0, 0, large_vid_bitmap.w, 30, makecol(255, 0, 0));
        line(large_vid_bitmap, large_vid_bitmap.w, 0, 0, large_vid_bitmap.h, makecol(255, 0, 0));

        proxy_vid_bitmap = create_video_bitmap(100, 100);
        clear_to_color(proxy_vid_bitmap, CYAN());
        line(proxy_vid_bitmap, 0, 0, proxy_vid_bitmap.w, proxy_vid_bitmap.h, makecol(255, 0, 0));

        /* memory -> video */
        blit(mem_bitmap, proxy_vid_bitmap, 0, 0, 5, 5, mem_bitmap.w, mem_bitmap.h);

        set_alpha_blender();
        /* memory -> video trans */
        draw_trans_sprite(proxy_vid_bitmap, trans_mem_bitmap, mem_bitmap.w, 5);
        /* video -> video trans */
        draw_trans_sprite(proxy_vid_bitmap, trans_vid_bitmap, 5, mem_bitmap.h);

        {	/* textured 3d polygon -> video bitmap */
            V3D_f v1 = new V3D_f(0, 0, 0, 0, 0, 0), v2 = new V3D_f(0, 0, 0, 0, 0, 0), v3 = new V3D_f(0, 0, 0, 0, 0, 0), v4 = new V3D_f(0, 0, 0, 0, 0, 0);
            v1.x = 50; v1.y = 50; v1.u = 0; v1.v = 0;
            v2.x = 98; v2.y = 50; v2.u = 70; v2.v = 0;
            v3.x = 98; v3.y = 98; v3.u = 70; v3.v = 70;
            v4.x = 50; v4.y = 98; v4.u = 0; v4.v = 70;
            quad3d_f(proxy_vid_bitmap, POLYTYPE_ATEX, vid_pattern, ref v1, ref v2, ref v3, ref v4);
        }

        /* video -> video */
        draw_sprite(large_vid_bitmap, proxy_vid_bitmap, 5, 5);

        textout_ex(large_vid_bitmap, font, "some text", 15, 35, -1, -1);

        install_keyboard();

        LOCK_VARIABLE(chrono);
        LOCK_FUNCTION(_the_timer);

        install_int(_the_timer, 5);

        /* Setup OpenGL like we want */
        OpenGL.glEnable(OpenGL.GL_TEXTURE_2D);


        do
        {
            if (keypressed())
                keypress = readkey();
            else
                keypress = 0;

            rotate += 1.0f;
            if (rotate > 360.0) rotate = 0;

            OpenGL.glClear(OpenGL.GL_DEPTH_BUFFER_BIT | OpenGL.GL_COLOR_BUFFER_BIT);

            OpenGL.glPushMatrix();
            OpenGL.glRotatef(45, 1, 0, 0);
            OpenGL.glRotatef(rotate, 0.0f, 1.0f, 0.0f);
            OpenGL.glBegin(OpenGL.GL_QUADS);
            OpenGL.glColor3f(1.0f, 0.0f, 1.0f);
            OpenGL.glVertex3f(0.1f, 0.1f, 0.1f);
            OpenGL.glVertex3f(0.1f, -0.1f, 0.1f);
            OpenGL.glVertex3f(-0.1f, -0.1f, 0.1f);
            OpenGL.glVertex3f(-0.1f, 0.1f, 0.1f);
            OpenGL.glColor3f(1.0f, 0.0f, 0.0f);
            OpenGL.glVertex3f(0.1f, 0.1f, -0.1f);
            OpenGL.glVertex3f(0.1f, -0.1f, -0.1f);
            OpenGL.glVertex3f(-0.1f, -0.1f, -0.1f);
            OpenGL.glVertex3f(-0.1f, 0.1f, -0.1f);
            OpenGL.glColor3f(0.0f, 1.0f, 0.0f);
            OpenGL.glVertex3f(0.1f, 0.1f, 0.1f);
            OpenGL.glVertex3f(0.1f, -0.1f, 0.1f);
            OpenGL.glVertex3f(0.1f, -0.1f, -0.1f);
            OpenGL.glVertex3f(0.1f, 0.1f, -0.1f);
            OpenGL.glEnd();
            OpenGL.glPopMatrix();

            frame_count++;

            if (frame_count >= 20)
            {
                if (chrono - frame_count_time != 0)
                    fps_rate = frame_count * 200.0f / (chrono - frame_count_time);
                else
                    fps_rate = frame_count * 200.0f;
                frame_count_time = chrono;
                frame_count = 0;
            }

            allegro_gl_set_allegro_mode();
            line(screen, 0, 0, 640, 480, makecol(0xff, 0, 0xff));
            triangle(screen, 115, 21, 150, 350, 5, 90, makecol(0xff, 0, 0));
            triangle(screen, 145, 21, 190, 350, 45, 90, makecol(0, 0, 0xff));
            triangle(screen, 205, 21, 240, 350, 95, 90, makecol(0, 0xff, 0xff));
            triangle(screen, 245, 21, 290, 350, 145, 90, makecol(0xff, 0xff, 0));
            rect(screen, 0, 0, 639, 479, makecol(0xff, 0xbf, 0x00));
            putpixel(screen, 0, 0, makecol(0xff, 0xff, 0xff));
            putpixel(screen, 639, 0, makecol(0xff, 0xff, 0xff));
            putpixel(screen, 0, 479, makecol(0xff, 0xff, 0xff));
            putpixel(screen, 639, 479, makecol(0xff, 0xff, 0xff));
            putpixel(screen, 0, 478, makecol(0xff, 0xff, 0xff));
            putpixel(screen, 639, 478, makecol(0xff, 0xff, 0xff));
            rectfill(screen, 16, 300, 256, 420, makecol(0xff, 0xff, 0xff));

            textout_ex(screen, font, "Partially cut off text", -3, 450,
                    makecol(255, 255, 255), -1);
            textout_ex(screen, font, "Hello World!", 70, 330, BLACK(), -1);
            textprintf_ex(screen, font, 70, 350, makecol(0, 0, 0), -1,
                       string.Format(CultureInfo.InvariantCulture, "FPS: {0:0.00}", fps_rate));

            /* Now here's the interesting part. This section of code tests
             * the various blit combinations supported by AllegroGL. That is:
             *                 screen -> sub-bitmap of screen
             *   sub-bitmap of screen -> sub-bitmap of screen
             *                 screen -> screen
             *           video bitmap -> screen
             *                 screen -> memory bitmap
             *          memory bitmap -> screen
             *             rle sprite -> screen
             *
             *   Other combinations are tested either at the init.
             */

            blit(screen, sub_screen, 256, 192, 0, 0, 128, 96);
            blit(sub_screen, sub_screen2, 0, 0, 0, 0, 128, 96);
            blit(screen, screen, 0, 0, 400, 150, 90, 90);
            blit(vid_bitmap, screen, 0, 0, 0, 0, 50, 50);
            blit(vid_bitmap2, screen, 0, 0, 50, 0, 50, 50);
            blit(screen, mem_bitmap, 0, 0, 0, 0, 50, 50);
            blit(mem_bitmap, screen, 0, 0, 100, 0, 50, 50);

            masked_blit(vid_bitmap, screen, 0, 0, 0, 50, 50, 50);
            masked_blit(vid_bitmap2, screen, 0, 0, 50, 50, 50, 50);
            masked_blit(mem_bitmap, screen, 0, 0, 100, 50, 50, 50);

            draw_sprite(screen, vid_bitmap, 0, 100);
            draw_sprite(screen, vid_bitmap2, 50, 100);
            draw_sprite(screen, mem_bitmap, 100, 100);
            draw_rle_sprite(screen, rle_sprite, 150, 100);

            set_alpha_blender();
            draw_trans_sprite(screen, trans_vid_bitmap, 0, 150);
            draw_trans_sprite(screen, trans_vid_bitmap2, 50, 150);
            draw_trans_sprite(screen, trans_mem_bitmap, 100, 150);
            draw_trans_rle_sprite(screen, trans_rle_sprite, 150, 150);

            pivot_scaled_sprite(screen, vid_bitmap, 0, 200, 0, 0, itofix(6), ftofix(1.1));
            pivot_scaled_sprite(screen, vid_bitmap2, 50, 200, 0, 0, itofix(6), ftofix(1.1));
            pivot_scaled_sprite(screen, mem_bitmap, 100, 200, 0, 0, itofix(6), ftofix(1.1));

            /* Write the captions for each image */
            textout_ex(screen, font, "blit", 200, 25, CYAN(), BLACK());
            textout_ex(screen, font, "masked_blit", 200, 75, CYAN(), BLACK());
            textout_ex(screen, font, "draw_sprite", 200, 125, CYAN(), BLACK());
            textout_ex(screen, font, "draw_trans_sprite", 200, 175, CYAN(), BLACK());
            textout_ex(screen, font, "pivot_scaled_sprite", 200, 225, CYAN(), BLACK());
            textout_centre_ex(screen, font, "vid", 25, 275, CYAN(), BLACK());
            textout_centre_ex(screen, font, "NPOT", 25, 285, CYAN(), BLACK());
            textout_centre_ex(screen, font, "vid", 75, 275, CYAN(), BLACK());
            textout_centre_ex(screen, font, "POT", 75, 275, CYAN(), BLACK());
            textout_centre_ex(screen, font, "mem", 125, 275, CYAN(), BLACK());
            textout_centre_ex(screen, font, "rle", 175, 275, CYAN(), BLACK());

            drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
            rectfill(screen, 250, 400, 300, 450, CYAN());
            drawing_mode(DRAW_MODE_XOR, NULL, 0, 0);
            rect(screen, 270, 420, 280, 430, CYAN());
            solid_mode();

            polygon(screen, 6, poly_coords, CYAN());
            drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
            set_trans_blender(305, 255, 305, 128);
            rectfill(screen, 170, 400, 200, 450, BLACK());

            drawing_mode(DRAW_MODE_COPY_PATTERN, vid_pattern, 50, 50);
            triangle(screen, 320, 350, 430, 350, 320, 480, 0);
            rectfill(screen, 400, 400, 450, 450, 0);
            solid_mode();

            /* video -> screen stertching */
            stretch_blit(large_vid_bitmap, screen, 0, 0, large_vid_bitmap.w, large_vid_bitmap.h,
                         460, 350, large_vid_bitmap.w + 50, large_vid_bitmap.h);

            allegro_gl_unset_allegro_mode();

            if ((keypress & 0xdf) == 'S')
                blit(screen, save_bmp, 0, 0, 0, 0, 640, 480);

            OpenGL.glFlush();
            allegro_gl_flip();

            if ((keypress & 0xdf) == 'S')
            {
                save_bitmap("screen.bmp", save_bmp, desktop_palette);
            }

            rest(2);

        } while (!key[KEY_ESC]);

        allegro_gl_set_allegro_mode();
        OpenGL.glDrawBuffer(OpenGL.GL_FRONT);
        OpenGL.glReadBuffer(OpenGL.GL_FRONT);

        textout_ex(screen, font, "Press any key to exit...", 0, 470,
                makecol(255, 255, 255), -1);

        /* check the dialog saved the background OK */
        readkey();

        destroy_bitmap(save_bmp);
        destroy_bitmap(sub_screen);
        destroy_bitmap(sub_screen2);
        destroy_bitmap(mem_bitmap);
        destroy_bitmap(vid_bitmap);
        destroy_bitmap(vid_bitmap2);
        destroy_bitmap(trans_mem_bitmap);
        destroy_bitmap(trans_vid_bitmap);
        destroy_bitmap(trans_vid_bitmap2);
        destroy_bitmap(proxy_vid_bitmap);
        destroy_bitmap(large_vid_bitmap);
        destroy_bitmap(vid_pattern);
        destroy_rle_sprite(rle_sprite);
        destroy_rle_sprite(trans_rle_sprite);
        return 0;
    }
}