#include "renderpng.h"
#include "position.h"
#include "map.h"
#include "cell.h"

#include "image.h"
#include "palette.h"
#include "font.h"

#include <math.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

RenderPng::RenderPng( Map &rMap ) :
    rMap( rMap )
{
}

RenderPng::~RenderPng()
{
}

void RenderPng::render()
{
    int iDims = rMap.getDims();
    int iSize = 1;
    if( iDims > 2 )
        iSize = (int)ceil(sqrt((rMap.getDims()-2)*2));

    int iCellSize = 11;
    int iFloorSpacing = 15;
    int iCellMid = iCellSize/2;
    int iBufWidth = ((iSize+1)*rMap.getSize( 0 )+1)*iCellSize;
    int iBufHeight = ((iSize+1)*rMap.getSize( 1 )+1)*iCellSize+12;
    int iFloorWidth = iBufWidth;
    int iFloorHeight = iBufHeight;

    int *aiPixDims = new int[iDims];
    aiPixDims[0] = iBufHeight+iFloorSpacing;
    aiPixDims[1] = iBufWidth+iFloorSpacing;

    for( int j = 2; j < iDims; j++ )
    {
        if( j%2 == 0 )
        {
            aiPixDims[j] = iBufHeight = rMap.getSize( j )*(iBufHeight+(j/2)*iFloorSpacing);
//            if( j >= 4 )
//                iBufHeight += j*24;
        }
        else
        {
            aiPixDims[j] = iBufWidth = rMap.getSize( j )*(iBufWidth+(j/2)*iFloorSpacing);
//            if( j >= 4 )
//                iBufWidth += (j*24);
        }
    }
    int ox = 0;
    int oy = 12;
    Image im( iBufWidth, iBufHeight );
    Font fnt("ter-u12n.bdf");
    im.clear( 1 );
    Palette pal;
    pal.addColor( 0, 0, 0 );
    pal.addColor( 255, 255, 255 );

    Position p( iDims );
    for(;;)
    {
        int x = p[0]*(iSize+1);
        int y = p[1]*(iSize+1);
        int iWalls = rMap[p].iWalls;
                  
        for( int iRow = 0; iRow < iSize+2; iRow++ )
        {
            for( int iCol = 0; iCol < iSize+2; iCol++ )
            {
                if( (iRow == 0 || iRow == iSize+1) &&
                    (iCol == 0 || iCol == iSize+1) )
                {
                    im.set(
                        ox+(x+iCol)*iCellSize+iCellMid,
                        oy+(y+iRow)*iCellSize+iCellMid,
                        0
                        );
                    if( iRow == 0 && iCol == 0 )
                    {
                        if( (iWalls&(1<<2)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+i+iCellMid+1,
                                    oy+(y+iRow)*iCellSize+iCellMid,
                                    0
                                    );
                        }
                        if( (iWalls&(1<<0)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+iCellMid,
                                    oy+(y+iRow)*iCellSize+i+iCellMid+1,
                                    0
                                    );
                        }
                    }
                    else if( iRow == 0 && iCol == iSize+1 )
                    {
                        if( (iWalls&(1<<2)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+i,
                                    oy+(y+iRow)*iCellSize+iCellMid,
                                    0
                                    );
                        }
                        if( (iWalls&(1<<1)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+iCellMid,
                                    oy+(y+iRow)*iCellSize+i+iCellMid+1,
                                    0
                                    );
                        }
                    }
                    else if( iRow == iSize+1 && iCol == 0 )
                    {
                        if( (iWalls&(1<<3)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+i+iCellMid+1,
                                    oy+(y+iRow)*iCellSize+iCellMid,
                                    0
                                    );
                        }
                        if( (iWalls&(1<<0)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+iCellMid,
                                    oy+(y+iRow)*iCellSize+i,
                                    0
                                    );
                        }
                    }
                    else if( iRow == iSize+1 && iCol == iSize+1 )
                    {
                        if( (iWalls&(1<<3)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+i,
                                    oy+(y+iRow)*iCellSize+iCellMid,
                                    0
                                    );
                        }
                        if( (iWalls&(1<<1)) == 0 )
                        {
                            for( int i = 0; i < iCellMid+1; i++ )
                                im.set(
                                    ox+(x+iCol)*iCellSize+iCellMid,
                                    oy+(y+iRow)*iCellSize+i,
                                    0
                                    );
                        }
                    }
                }
                else if( iRow == 0 && (iWalls&(1<<2)) == 0 )
                {
                    for( int i = 0; i < iCellSize; i++ )
                    {
                        im.set(
                            ox+(x+iCol)*iCellSize+i,
                            oy+(y+iRow)*iCellSize+iCellMid,
                            0
                            );
                    }
                }
                else if( iRow == iSize+1 && (iWalls&(1<<3)) == 0 )
                {
                    for( int i = 0; i < iCellSize; i++ )
                    {
                        im.set(
                            ox+(x+iCol)*iCellSize+i,
                            oy+(y+iRow)*iCellSize+iCellMid,
                            0
                            );
                    }
                }
                else if( iCol == 0 && (iWalls&(1<<0)) == 0 )
                {
                    for( int i = 0; i < iCellSize; i++ )
                    {
                        im.set(
                            ox+(x+iCol)*iCellSize+iCellMid,
                            oy+(y+iRow)*iCellSize+i,
                            0
                            );
                    }
                }
                else if( iCol == iSize+1 && (iWalls&(1<<1)) == 0 )
                {
                    for( int i = 0; i < iCellSize; i++ )
                    {
                        im.set(
                            ox+(x+iCol)*iCellSize+iCellMid,
                            oy+(y+iRow)*iCellSize+i,
                            0
                            );
                    }
                }
            }
        }

        for( int j = 2; j < iDims; j++ )
        {
            for( int side = 0; side < 2; side++ )
            {
                int d = j*2+side;
                if( iWalls&(1<<d) )
                {
                    int iSubX = (x+1+((d-4)%iSize))*iCellSize;
                    int iSubY = (y+1+((d-4)/iSize))*iCellSize;

                    switch( d )
                    {
                        case 4:
                            im.set( ox+iSubX+iCellMid, oy+iSubY+1, 0 );
                            for( int m = 0; m < iCellMid; m++ )
                            {
                                im.set( ox+iSubX+m, oy+iSubY+iCellMid-m+1, 0 );
                                im.set( ox+iSubX+iCellMid+m+1, oy+iSubY+m+2, 0 );
                            }
                            break;

                        case 5:
                            im.set( ox+iSubX+iCellMid, oy+iSubY+iCellSize-2, 0 );
                            for( int m = 0; m < iCellMid; m++ )
                            {
                                im.set( ox+iSubX+m, oy+iSubY+iCellMid+m-1, 0 );
                                im.set( ox+iSubX+iCellMid+m+1, oy+iSubY+iCellSize-m-3, 0 );
                            }
                            break;

                        case 6:
                            im.set( ox+iSubX+1, oy+iSubY+iCellMid, 0 );
                            for( int m = 0; m < iCellMid; m++ )
                            {
                                im.set( ox+iSubX+iCellMid-m+1, oy+iSubY+m, 0 );
                                im.set( ox+iSubX+m+2, oy+iSubY+iCellMid+m+1, 0 );
                            }
                            break;

                        case 7:
                            im.set( ox+iSubX+iCellSize-2, oy+iSubY+iCellMid, 0 );
                            for( int m = 0; m < iCellMid; m++ )
                            {
                                im.set( ox+iSubX+iCellMid+m-1, oy+iSubY+m, 0 );
                                im.set( ox+iSubX+iCellSize-m-3, oy+iSubY+iCellMid+m+1, 0 );
                            }
                            break;
                    }
                }
            }
        }

        int iDim;
        char title[1024];
        for( iDim = 0; iDim < iDims; iDim++ )
        {
            if( ++p[iDim] < rMap.getSize( iDim ) )
                break;
            p[iDim] = 0;
            if( iDim == 1 )
            {
                if( iDims > 2 )
                {
                    char buf[1024];
                    sprintf( buf, "Floor: %d", rMap.getSize(2)-p[2] );
                    strcpy( title, buf );
                    for( int j = 3; j < iDims; j++ )
                    {
                        sprintf( buf, ", %d", rMap.getSize(j)-p[j] );
                        strcat( title, buf );
                    }
                }
                else
                    title[0] = '\0';
                printf("Completed %s\n", title );
                im.drawText( fnt, ox, oy-2, 0, title );
            }
        }
        if( iDim == iDims )
            break;
        else if( iDim >= 2 )
        {
            ox = oy = 0;
            for( int j = 2; j < iDims; j++ )
            {
                if( j%2 == 0 )
                {
                    oy += p[j]*aiPixDims[j-2];
                    if( j >= 4 )
                        oy += (p[j]*(j/2)*iFloorSpacing);
                }
                else
                {
                    ox += p[j]*aiPixDims[j-2];
                    if( j >= 4 )
                        ox += (p[j]*(j/2)*iFloorSpacing);
                }
            }
            oy += 12;
        }
    }

    printf("Saving image to: lost.png\n");
    im.save("lost.png", pal );

    delete[] aiPixDims;
}