package MapClasses;
import Classes.*;
import org.newdawn.slick.*;

public class MapBase
{
    //Units
    Unit[] units = new Unit[128];

    //Rounds; adds one each time all units are run through in initiative
    int round = 0;
    //Turns
    int turns = 0;

    int X;
    int Y;

    TileManager tm;
    public MapBase(int x, int y)
    {
        tm = new TileManager(x, y);
        X = x;
        Y = y;
    }

    public void defineUnit(int UnitPosInArray, int tilenum, float Heightt, float Move,
            float HP, float MP, float WS, float BS, float MS, float S,
            float T, float Ag, float Int, float WP, float Cha, float LUK,
            float Mov, long randseed)
    {
        units[UnitPosInArray] = new Unit(tm, tilenum, Heightt, Move, HP, MP, WS, BS, MS, S, T, Ag,
                Int, WP, Cha, LUK, Mov, randseed);
    }
    boolean IsItYourTurn()
    {
        if(units[turns].isTurn)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public void TurnChange()
    {
        if(turns < getNumUnits(units) - 1)
        {
            turns++;
        }
        else
        {
            turns = 0;
            round++;
        }
        if(units[turns] != null)
        {
            units[turns].isTurn = true;
            if(turns > 0)
            {
                units[turns-1].isTurn = false;
            }
        }
    }
    public Unit[] sortUnitInit()
    {

        float min = units[getNumUnits(units)-1].initiative;
        float max = units[0].initiative;
        float prevmax = max;
                for(int j =0, l = 0; j < getNumUnits(units); j++)
                {
                    units[l].initiative = max;
                    if(prevmax < max && prevmax > min)
                    {
                        units[j].initiative = prevmax;
                    }
                    units[getNumUnits(units)-1].initiative = min;
                    for(int ex = 0; ex < getNumUnits(units); ex++)
                    {
                        if(min > units[ex].initiative)
                        {
                            min = units[ex].initiative;
                        }
                           if(max < units[ex].initiative)
                           {
                               prevmax = max;
                               //Have to make the prevmax into the next lowest number!!
                               max = units[ex].initiative;
                           }
                           else if(prevmax > units[ex].initiative)
                           {
                               prevmax = units[ex].initiative;
                           }
                    }
                      for(int number = 0; number < getNumUnits(units); number++)
                      {
                          System.out.println(number + " " + units[number].initiative);
                      }
                }


        return units;
    }


    int getNumUnits(Unit[] unittt)
    {
        int numUnits = 0;
        int count = 0;
        while(unittt[count] != null)
        {
            count++;
            numUnits++;
        }
        return numUnits;
    }


    public void SkipTurn()
    {
        turns++;
    }
        public void rollUnitInit ()
    {
            int j = 0;
            while(units[j] != null)
            {
                units[j].rollInitiative();
                j++;

            }


                    int p = 1;
                        if(getNumUnits(units) < 21)
                        {
                            while(units[p-1] != null && units[p] != null && units[p-1].initiative == units[p].initiative)
                            {
                                    units[p].rollInitiative();
                                    p++;
                            }
                        }

                        else
                        {
                            while(units[p-1] != null && units[p] != null && units[p-1].initiative == units[p].initiative)
                            {
                                units[p].plusInit();
                                p++;
                            }
                        }


            }
    public void TileWholeMap(GameContainer gc)
    {

        tm.generateTileRow(5, 2);
        for(int why = 4; why < gc.getHeight(); why+=4)
        {
        tm.generateTileRow(0, why, 5, 2);
        }
    }
    public float getUnitX(int UnitPosInArray)
    {
        return units[UnitPosInArray].x;
    }

    public float getUnitY(int UnitPosInArray)
    {
        return units[UnitPosInArray].y;
    }

    public void moveUnit(String direction)
    {
        if(direction.equals("LEFT"))
        {
            units[turns].moveUnitLeft(X);
        }
        else if(direction.equals("RIGHT"))
        {
            units[turns].moveUnitRight(X);
        }
        else if(direction.equals("UP"))
        {
            units[turns].moveUnitUp(X, Y);
        }
        else if(direction.equals("DOWN"))
        {
            units[turns].moveUnitDown(X, Y);
        }
    }
}