#include "World.h"


#include "common.h"
#include "map.h"


#include "minorGems/graphics/Image.h"
#include "minorGems/util/SimpleVector.h"





class GraphicContainer {
    
    public:
        
        GraphicContainer( const char *inTGAFileName ) {
        
            Image *image = readTGA( inTGAFileName );
    
            mW = image->getWidth();
            mH = image->getHeight();
            int imagePixelCount = mW * mH;
    
            mRed =  new double[ imagePixelCount ];
            mGreen =  new double[ imagePixelCount ];
            mBlue =  new double[ imagePixelCount ];
            
            for( int i=0; i<imagePixelCount; i++ ) {
                mRed[i] = 255 * image->getChannel(0)[ i ];
                mGreen[i] = 255 * image->getChannel(1)[ i ];
                mBlue[i] = 255 * image->getChannel(2)[ i ];
                }
            delete image;
            }
        
        
        ~GraphicContainer() {
            delete [] mRed;
            delete [] mGreen;
            delete [] mBlue;
            }
        
        
        double *mRed;
        double *mGreen;
        double *mBlue;
        
        int mW;
        int mH;
        
    
    };








GraphicContainer *tileContainer;
GraphicContainer *chestContainer;

GraphicContainer *spriteContainer;
GraphicContainer *spriteSadContainer;
GraphicContainer *spouseContainer;

GraphicContainer *prizeAnimationContainer;
GraphicContainer *dustAnimationContainer;
GraphicContainer *heartAnimationContainer;


// dimensions of one tile.  TileImage contains 13 tiles, stacked vertically,
// with blank lines between tiles
int tileW = 8;
int tileH = 8;

int tileImageW;
int tileImageH;


int numTileSets;

// how wide the swath of a world is that uses a given tile set
int tileSetWorldSpan = 200;
// overlap during tile set transition
int tileSetWorldOverlap = 50;

// for testing
int tileSetSkip = 0;

int tileSetOrder[18] = { 0, 2, 10, 1, 8, 3, 5, 6, 4, 7, 13, 9, 15, 
                         14, 16, 12, 11, 17 };



int mapTileSet( int inSetNumber ) {
    // stay in bounds of tileSetOrder
    inSetNumber = inSetNumber % 18;
    
    int mappedSetNumber = tileSetOrder[ inSetNumber ];
    
    // stay in bounds of tile set collection
    return mappedSetNumber % numTileSets;
    }





int chestW = 8;
int chestH = 8;

int numGems = 6;
int gemLocations[6] = { 41, 42, 43, 44, 45, 46 };
//int gemLocations[4] = { 10, 11, 12, 13 };
double gemColors[6][3] = { { 255, 0, 0 }, 
                           { 0, 255, 0 }, 
                           { 255, 160, 0 }, 
                           { 0, 0, 255 }, 
                           { 255, 255, 0 },
                           { 255, 0, 255 } };




class Animation {
    public:
        
        Animation( int inX, int inY, int inFrameW, int inFrameH,
                   char inAutoStep,
                   char inRemoveAtEnd, GraphicContainer *inGraphics )
                : mX( inX ), mY( inY ), 
                  mFrameW( inFrameW ), mFrameH( inFrameH ),
                  mPageNumber( 0 ),
                  mFrameNumber( 0 ),
                  mAutoStep( inAutoStep ),
                  mRemoveAtEnd( inRemoveAtEnd ),
                  mGraphics( inGraphics ) {
            
            mImageW = mGraphics->mW;
            
            mNumFrames = ( mGraphics->mH - mFrameH ) / mFrameH + 1;
            mNumPages = ( mGraphics->mW - mFrameW ) / mFrameW + 1;
            }
        
        // default constructor so that we can build a vector
        // of Animations
        Animation() {
            }
        
        
        // replaces graphics of animation
        void swapGraphics( GraphicContainer *inNewGraphics ) {
        
            mGraphics = inNewGraphics;
            
            mImageW = mGraphics->mW;
            
            mNumFrames = ( mGraphics->mH - mFrameH ) / mFrameH + 1;
            mNumPages = ( mGraphics->mW - mFrameW ) / mFrameW + 1;
            
            if( mPageNumber >= mNumPages ) {
                mPageNumber = mNumPages - 1;
                }
            if( mFrameNumber >= mNumFrames ) {
                mFrameNumber = mNumFrames - 1;
                }
            }
        
        

        int mX, mY;
        
        
        int mFrameW, mFrameH;
        int mImageW;
        
        // can blend between pages
        double mPageNumber;

        int mNumPages;
        
        int mFrameNumber;
        int mNumFrames;
        char mAutoStep;
        char mRemoveAtEnd;
        
        
        GraphicContainer *mGraphics;
        
    };



SimpleVector<Animation> animationList;




// pointers into vectors are unsafe
//Animation *spriteAnimation;
//Animation *spouseAnimation;

int spriteAnimationIndex;
int spouseAnimationIndex;



char playerDead = false;
char spouseDead = false;
char metSpouse = false;



void resetSampleHashTable();



void initWorld() {
    resetMap();
    resetSampleHashTable();
    
    playerDead = false;
    spouseDead = false;
    metSpouse = false;
    
    animationList.deleteAll();
    

    tileImageW = tileContainer->mW;
    tileImageH = tileContainer->mH;
    
    numTileSets = (tileImageW + 1) / (tileW + 1);
    
    Animation character(  0, 0, 8, 8, false, false, spriteContainer );
    
    
    animationList.push_back( character );
    
    // unsafe
    // get pointer to animation in vector
    //spriteAnimation = animationList.getElement( animationList.size() - 1 );
    spriteAnimationIndex = animationList.size() - 1;

    Animation spouse(  100, 7, 8, 8, false, false, spouseContainer );
    spouse.mFrameNumber = 7;
    
    
    animationList.push_back( spouse );
    
    // unsafe!
    // get pointer to animation in vector
    //spouseAnimation = animationList.getElement( animationList.size() - 1 );
    spouseAnimationIndex = animationList.size() - 1;
    }








char isSpriteTransparent( GraphicContainer *inContainer, int inSpriteIndex ) {
    
    // take transparent color from corner
    return 
        inContainer->mRed[ inSpriteIndex ] == 
        inContainer->mRed[ 0 ]
        &&
        inContainer->mGreen[ inSpriteIndex ] == 
        inContainer->mGreen[ 0 ]
        &&
        inContainer->mBlue[ inSpriteIndex ] == 
        inContainer->mBlue[ 0 ];
    }



struct rgbColorStruct {
    double r;
    double g;
    double b;
    };
typedef struct rgbColorStruct rgbColor;


 
// outTransient set to true if sample returned is part of a transient
// world feature (character sprite, chest, etc.)
rgbColor sampleFromWorldNoWeight( int inX, int inY, char *outTransient );

// same, but wrapped in a hash table to store non-transient results
rgbColor sampleFromWorldNoWeightHash( int inX, int inY );



Uint32 sampleFromWorld( int inX, int inY, double inWeight ) {
    rgbColor c = sampleFromWorldNoWeightHash( inX, inY );
    
    unsigned char r = (unsigned char)( inWeight * c.r );
    unsigned char g = (unsigned char)( inWeight * c.g );
    unsigned char b = (unsigned char)( inWeight * c.b );
    

    return r << 16 | g << 8 | b;
    }



char isSpritePresent( int inX, int inY ) {
    // look at animations
    for( int i=0; i<animationList.size(); i++ ) {
        Animation a = *( animationList.getElement( i ) );
        
        int animW = a.mFrameW;
        int animH = a.mFrameH;
        
        
        // pixel position relative to animation center
        // player position centered on sprint left-to-right
        int animX = (int)( inX - a.mX + a.mFrameW / 2 );
        int animY = (int)( inY - a.mY + a.mFrameH / 2 );
        
        if( animX >= 0 && animX < animW
            && 
            animY >= 0 && animY < animH ) {
            return true;
            }
        
        }
    

    return false;
    }



#include "HashTable.h"

HashTable<rgbColor> worldSampleHashTable( 30000 );


void resetSampleHashTable() {
    worldSampleHashTable.clear();
    }



rgbColor sampleFromWorldNoWeightHash( int inX, int inY ) {
    
    char found;
    
    rgbColor sample = worldSampleHashTable.lookup( inX, inY, &found );
    
    if( isSpritePresent( inX, inY ) ) {
        // don't consider cached result if a sprite is present
        found = false;
        }
            

    if( found ) {
        return sample;
        }
    
    // else not found
    
    // call real function to get result
    char transient;
    sample = sampleFromWorldNoWeight( inX, inY, &transient );
    
    // insert, but only if not transient
    if( !transient ) {
        worldSampleHashTable.insert( inX, inY, sample );
        }
    
    return sample;
    }



rgbColor sampleFromWorldNoWeight( int inX, int inY, char *outTransient ) {
    *outTransient = false;

    rgbColor returnColor;
    
    char isSampleAnim = false;
    
    // consider sampling from an animation
    // draw them in reverse order so that oldest sprites are drawn on top
    for( int i=animationList.size() - 1; i>=0; i-- ) {

        Animation a = *( animationList.getElement( i ) );
        
        int animW = a.mFrameW;
        int animH = a.mFrameH;
        
        
        // pixel position relative to animation center
        // player position centered on sprint left-to-right
        int animX = (int)( inX - a.mX + a.mFrameW / 2 );
        int animY = (int)( inY - a.mY + a.mFrameH / 2 );
        
        if( animX >= 0 && animX < animW
            && 
            animY >= 0 && animY < animH ) {
                        
            // pixel is in animation frame

            int animIndex = animY * a.mImageW + animX;
        
            // skip to appropriate anim page
            animIndex += (int)a.mPageNumber * (animW + 1);
            
            
            // skip to appropriate anim frame
            animIndex += 
                a.mFrameNumber * 
                a.mImageW * 
                ( animH + 1 );
            
            // page to blend with
            int animBlendIndex = animIndex + animW + 1;
            
            double blendWeight = a.mPageNumber - (int)a.mPageNumber;
            
        
            if( !isSpriteTransparent( a.mGraphics, animIndex ) ) {
            
                // in non-transparent part
            
                if( blendWeight != 0 ) {
                    returnColor.r = 
                        ( 1 - blendWeight ) * a.mGraphics->mRed[ animIndex ] 
                        +
                        blendWeight * a.mGraphics->mRed[ animBlendIndex ];
                    returnColor.g = 
                        ( 1 - blendWeight ) * a.mGraphics->mGreen[ animIndex ] 
                        +
                        blendWeight * a.mGraphics->mGreen[ animBlendIndex ];
                    returnColor.b = 
                        ( 1 - blendWeight ) * a.mGraphics->mBlue[ animIndex ] 
                        +
                        blendWeight * a.mGraphics->mBlue[ animBlendIndex ];
                    }
                else {
                    // no blend
                    returnColor.r = a.mGraphics->mRed[ animIndex ];
                    returnColor.g = a.mGraphics->mGreen[ animIndex ];
                    returnColor.b = a.mGraphics->mBlue[ animIndex ];
                    }
                
                *outTransient = true;
                // don't return here, because there might be other
                // animations and sprites that are on top of
                // this one
                isSampleAnim = true;
                }
            }
        }

    if( isSampleAnim ) {
        // we have already found an animation here that is on top
        // of whatever map graphics we might sample below
        
        // thus, we can return now
        return returnColor;
        }
    


    int tileIndex;
    
    char blocked = isBlocked( inX, inY );
    
    if( !blocked ) {
        // empty tile
        tileIndex = 0;
        }
    else {
        
        int neighborsBlockedBinary = 0;
        
        if( isBlocked( inX, inY - tileH ) ) {
            // top
            neighborsBlockedBinary = neighborsBlockedBinary | 1;
            }
        if( isBlocked( inX + tileW, inY ) ) {
            // right
            neighborsBlockedBinary = neighborsBlockedBinary | 1 << 1;
            }
        if( isBlocked( inX, inY + tileH ) ) {
            // bottom
            neighborsBlockedBinary = neighborsBlockedBinary | 1 << 2;
            }
        if( isBlocked( inX - tileW, inY ) ) {
            // left
            neighborsBlockedBinary = neighborsBlockedBinary | 1 << 3;
            }
    
        // skip empty tile, treat as tile index
        neighborsBlockedBinary += 1;
        
        tileIndex = neighborsBlockedBinary;
        }
    
    

    // pick a tile set
    int netWorldSpan = tileSetWorldSpan + tileSetWorldOverlap;

    int tileSet = inX / netWorldSpan + tileSetSkip;
    int overhang = inX % netWorldSpan;
    if( inX < 0 ) {
        // fix to a constant tile set below 0
        overhang = 0;
        tileSet = 0;
        }
    
    // is there blending with next tile set?
    int blendTileSet = tileSet + 1;
    double blendWeight = 0;
    
    if( overhang > tileSetWorldSpan ) {
        blendWeight = ( overhang - tileSetWorldSpan ) / 
            (double) tileSetWorldOverlap;
        }
    // else 100% blend of our first tile set


    tileSet = tileSet % numTileSets;
    blendTileSet = blendTileSet % numTileSets;
    
    // make sure not negative
    if( tileSet < 0 ) {
        tileSet += numTileSets;
        }
    if( blendTileSet < 0 ) {
        blendTileSet += numTileSets;
        }
    
    
    // apply mapping
    tileSet = mapTileSet( tileSet );
    blendTileSet = mapTileSet( blendTileSet );


    // sample from tile image
    int imageY = inY % tileH;
    int imageX = inX % tileW;
    

    if( imageX < 0 ) {
        imageX += tileW;
        }
    if( imageY < 0 ) {
        imageY += tileH;
        }
    
    // offset to top left corner of tile
    int tileImageOffset = tileIndex * ( tileH + 1 ) * tileImageW
        + tileSet * (tileW + 1);
    int blendTileImageOffset = tileIndex * ( tileH + 1 ) * tileImageW
        + blendTileSet * (tileW + 1);
    
    
    int imageIndex =  tileImageOffset + imageY * tileImageW + imageX;
    int blendImageIndex =  blendTileImageOffset + imageY * tileImageW + imageX;
    
    returnColor.r = 
        (1-blendWeight) * tileContainer->mRed[ imageIndex ] +
        blendWeight * tileContainer->mRed[ blendImageIndex ];
    
    returnColor.g =  
        (1-blendWeight) * tileContainer->mGreen[ imageIndex ] +
        blendWeight * tileContainer->mGreen[ blendImageIndex ];
    
    returnColor.b =  
        (1-blendWeight) * tileContainer->mBlue[ imageIndex ] +
        blendWeight * tileContainer->mBlue[ blendImageIndex ];
    
    
    // only consider drawing chests in empty spots
    if( !blocked && isChest( inX, inY ) ) {
        // draw chest here

        char chestType = isChest( inX, inY );
        

        // sample from chest image
        int imageY = inY % chestH;
        int imageX = inX % chestW;
    

        if( imageX < 0 ) {
            imageX += chestW;
            }
        if( imageY < 0 ) {
            imageY += chestH;
            }

        int spriteIndex = 0;
        
        if( chestType == CHEST_OPEN ) {
            spriteIndex = 1;
            }
        
        // skip to sub-sprite
        int spriteOffset = 
            spriteIndex * 
            chestW * 
            ( chestH + 1 );
        
        int subSpriteIndex = imageY * chestW + imageX;
        
        int imageIndex = spriteOffset + subSpriteIndex;
        
        if( !isSpriteTransparent( chestContainer, imageIndex ) ) {
            
            if( chestType == CHEST_CLOSED ) {
                *outTransient = true;
                }
            
            // check if this is one of the gem locations
            char isGem = false;
            int gemNumber = 0;
            
            for( int i=0; i<numGems && !isGem; i++ ) {
                if( subSpriteIndex == gemLocations[ i ] ) {
                    isGem = true;
                    gemNumber = i;
                    }
                }
            
            char gemColorUsed = false;
            
            if( isGem ) {
                // check if our gem is turned on for this chest
                unsigned char code = getChestCode( inX, inY );
                
                if( code & 0x01 << gemNumber ) {
                    
                    gemColorUsed = true;
                    
                    returnColor.r = gemColors[ gemNumber ][ 0 ];
                    returnColor.g = gemColors[ gemNumber ][ 1 ];
                    returnColor.b = gemColors[ gemNumber ][ 2 ];

                    }
                
                }
            

            if( !gemColorUsed ) {
                // use underlying chest color
                returnColor.r = chestContainer->mRed[ imageIndex ];
                returnColor.g = chestContainer->mGreen[ imageIndex ];
                returnColor.b = chestContainer->mBlue[ imageIndex ];
                }
            
            }
                
        }
        
        
    return returnColor;
    }






int getTileWidth() {
    return tileW;
    }



int getTileHeight() {
    return tileH;
    }



void destroyWorld() {
    /*
    printf( "%d hits, %d misses, %f hit ratio\n", 
            hitCount, missCount, hitCount / (double)( hitCount + missCount ) );
    */
    }



void stepAnimations() {
    
    
    for( int i=0; i<animationList.size(); i++ ) {
        Animation *a = animationList.getElement( i );
        if( a->mAutoStep ) {
            if( a->mFrameNumber < a->mNumFrames - 1 ) {
                a->mFrameNumber ++;
                }
            else if( a->mRemoveAtEnd ) {
                // remove it
                animationList.deleteElement( i );
                // back up in list for next loop iteration
                i--;
                }
            }
        
        }
    }



void startPrizeAnimation( int inX, int inY ) {

    Animation a( inX, inY, 16, 16, true, true, prizeAnimationContainer );
    
    animationList.push_back( a );
    }



void startDustAnimation( int inX, int inY ) {

    Animation a( inX, inY, 16, 16, true, true, dustAnimationContainer );
    
    animationList.push_back( a );
    }



void startHeartAnimation( int inX, int inY ) {

    Animation a( inX, inY, 16, 16, true, true, heartAnimationContainer );
    
    animationList.push_back( a );
    }





#include <math.h>


void setPlayerPosition( int inX, int inY ) {

    Animation *spriteAnimation = 
        animationList.getElement( spriteAnimationIndex );

    char moving = false;

    if( inX != spriteAnimation->mX ) {
        moving = true;
        }

    
    spriteAnimation->mX = inX;
    // player position centered at sprite's feet
    int newSpriteY = inY - spriteAnimation->mFrameH / 2 + 1;
    

    if( newSpriteY != spriteAnimation->mY ) {
        moving = true;
        }
    
    spriteAnimation->mY = newSpriteY;

    if( metSpouse && ! spouseDead ) {
        Animation *spouseAnimation = 
            animationList.getElement( spouseAnimationIndex );

        // spouse stands immediately in front of player
        int desiredSpouseX = inX + spouseAnimation->mFrameH;
        int desiredSpouseY = spriteAnimation->mY;

        // gravitates there gradually one pixel at a time in each x and y
        int dX = desiredSpouseX - spouseAnimation->mX;
        int dY = desiredSpouseY - spouseAnimation->mY;
        
        // convert to -1, 0, or +1
        if( dX != 0 ) {
            dX = (int)( dX / fabs( dX ) );
            }
        if( dY != 0 ) {
            dY = (int)( dY / fabs( dY ) );
            }
        
        if( moving ) {
            // only execute this transition when player is moving
            spouseAnimation->mX += dX;
            spouseAnimation->mY += dY;
            }


        // check for heart animation and have it track moving couple
        for( int i=0; i<animationList.size(); i++ ) {
            Animation *a = animationList.getElement( i );
            
            if( a->mGraphics == heartAnimationContainer ) {
                
                // move it halfway between player and spouse
                a->mX = ( spouseAnimation->mX - spriteAnimation->mX ) / 2 +
                    spriteAnimation->mX;
                a->mY = ( spouseAnimation->mY - spriteAnimation->mY ) / 2 +
                    spriteAnimation->mY + 1;
                }
            }
        
            
        }

    }



void setPlayerSpriteFrame( int inFrame ) {
    Animation *spriteAnimation = 
        animationList.getElement( spriteAnimationIndex );

    spriteAnimation->mFrameNumber = inFrame;
    
    if( metSpouse && ! spouseDead ) {
        Animation *spouseAnimation = 
            animationList.getElement( spouseAnimationIndex );
        
        // spouse follows player
        spouseAnimation->mFrameNumber = inFrame;
        }
    }



void setCharacterAges( double inAge ) {
    Animation *spriteAnimation = 
        animationList.getElement( spriteAnimationIndex );
    Animation *spouseAnimation = 
        animationList.getElement( spouseAnimationIndex );

    // 0 -> 0.25, constant page 0
    if( inAge <= 0.25 ) {
        spriteAnimation->mPageNumber = 0;
        spouseAnimation->mPageNumber = 0;
        }
    // 0.75 - 1.0, constant last page
    else if( inAge >= 0.75 ) {
        spriteAnimation->mPageNumber = spriteAnimation->mNumPages - 1;
        spouseAnimation->mPageNumber = spouseAnimation->mNumPages - 1;
        }
    else {
        // blend of pages in between
        double blendingAge = ( inAge - 0.25 ) / 0.5;
        
        spriteAnimation->mPageNumber = 
            blendingAge * ( spriteAnimation->mNumPages - 1 );

        spouseAnimation->mPageNumber = 
            blendingAge * ( spouseAnimation->mNumPages - 1 );
        }
    }



void getSpousePosition( int *outX, int *outY ) {
    Animation *spouseAnimation = 
        animationList.getElement( spouseAnimationIndex );
    
    *outX = spouseAnimation->mX;
    *outY = spouseAnimation->mY + spouseAnimation->mFrameH / 2 - 1;
    }



char haveMetSpouse() {
    return metSpouse && ! spouseDead;
    }



void meetSpouse() {
    metSpouse = true;
    }



void diePlayer() {
    Animation *spriteAnimation = 
        animationList.getElement( spriteAnimationIndex );

    playerDead = true;
    
    // tombstone
    spriteAnimation->mFrameNumber = 8;
    }



void dieSpouse() {
    Animation *spriteAnimation = 
        animationList.getElement( spriteAnimationIndex );
    Animation *spouseAnimation = 
        animationList.getElement( spouseAnimationIndex );

    spouseDead = true;
    
    // tombstone
    spouseAnimation->mFrameNumber = 8;
    
    if( metSpouse ) {
        // swap player sprite with sad sprite
        spriteAnimation->swapGraphics( spriteSadContainer );
        }
    }



char isPlayerDead() {
    return playerDead;
    }



char isSpouseDead() {
    return spouseDead;
    }



void loadWorldGraphics() {
    tileContainer = new GraphicContainer( "tileSet.tga" );
    chestContainer = new GraphicContainer( "chest.tga" );
      
    spriteContainer = new GraphicContainer( "characterSprite.tga" );
    spriteSadContainer = new GraphicContainer( "characterSpriteSad.tga" );
    spouseContainer = new GraphicContainer( "spouseSprite.tga" );
    
    prizeAnimationContainer = new GraphicContainer( "chestPrize.tga" );
    dustAnimationContainer = new GraphicContainer( "chestDust.tga" );
    heartAnimationContainer = new GraphicContainer( "heart.tga" );
    }



void destroyWorldGraphics() {
    delete tileContainer;
    delete chestContainer;
      
    delete spriteContainer;
    delete spriteSadContainer;
    delete spouseContainer;
    
    delete prizeAnimationContainer;
    delete dustAnimationContainer;
    delete heartAnimationContainer;
    }