package me.hammerle.supersnuvi.entity.components.ai;

import me.hammerle.snuviengine.api.Shader;
import me.hammerle.snuviengine.api.Texture;
import me.hammerle.supersnuvi.entity.Entity;
import me.hammerle.supersnuvi.tiles.Location;
import me.hammerle.supersnuvi.util.Face;
import me.hammerle.supersnuvi.util.Utils;

public class LondonerController extends Controller
{
    private final static Texture LONDONER = new Texture("resources/londoner.png");
    
    private final boolean evil;
    
    private float ox = 0.0f;
    private float tx = 0.0f;
    private float ty = 0.0f;
    
    private int walkFrame = 0;
    private int transformFrame = -1;
    private int deathCounter = 0;
    private int deathFrame = 0;
    
    private Face direction = Face.LEFT;

    public LondonerController(Entity ent, boolean evil) 
    {
        super(ent);
        this.evil = evil;
    }
    
    private boolean hasRedEyes()
    {
        return transformFrame >= 3;
    }
    
    @Override
    public boolean isAnimated()
    {
        return deathFrame < 7;
    }
    
    @Override
    public void tick() 
    {
        if(evil)
        {
            if(transformFrame != -1)
            {
                if(transformFrame < 3)
                {
                    ox = ent.getFace() == Face.RIGHT ? 0.0f: -36.0f;
                    tx = transformFrame * 0.125f + 0.125f;
                    ty = 0.375f;
                    transformFrame++;
                    return;
                }
            }
            else if(ent.getLevel().getHero().getSquaredDistance(ent) <= 16384) // 4 Tiles
            {
                transformFrame = 0;
            }
        }
        
        if(ent.getHealth().isDead())
        {
            ox = ent.getFace() == Face.RIGHT ? -32.0f: -4.0f;
            
            tx = deathFrame * 0.125f;
            ty = hasRedEyes() ? 0.125f : 0.25f;
            
            walkFrame = 0;
            deathCounter++;
            if(deathCounter >= 3)
            {
                deathCounter = 0;
                deathFrame++;
            }
            return;
        }
        
        if(hasRedEyes())
        {
            float hx = ent.getLevel().getHero().getCenterX();
            if(hx < ent.getCenterX())
            {
                ent.setMotionX(-ent.getMovement().getVelocityX());
            }
            else
            {
                ent.setMotionX(ent.getMovement().getVelocityX());
            }
        }
        else
        {
            if(direction == Face.LEFT)
            {
                ent.setMotionX(-ent.getMovement().getVelocityX());
            }
            else
            {
                ent.setMotionX(ent.getMovement().getVelocityX());
            }
        }
        
        ox = ent.getFace() == Face.RIGHT ? 0.0f: -36.0f;
        
        if(ent.isOnGround())
        {
            if(ent.getMotionX() == 0.0f)
            {
                tx = 0.875f;
                ty = hasRedEyes() ? 0.25f : 0.375f;
            }
            else
            {
                deathFrame = 0;
                walkFrame = (walkFrame + 1) % 6;
                tx = walkFrame * 0.125f;
                ty = hasRedEyes() ? 0.5f : 0.625f;
            }
        }
        else
        {
            deathFrame = 0;
            walkFrame = 0;
            tx = 0.125f;
            ty = hasRedEyes() ? 0.5f : 0.625f;
        }
    }

    @Override
    public void renderTick(float lag)
    {
        if(ent.getHealth().wasHurt())
        {
            Shader.setColorEnabled(true);
            Shader.setMixColorEnabled(true);
            Shader.setMixColor(1.0f, 0.0f, 0.0f, 1.0f);
        }
        if(ent.getHealth().wasHealed())
        {
            Shader.setColorEnabled(true);
            Shader.setMixColorEnabled(true);
            Shader.setMixColor(0.0f, 1.0f, 0.0f, 1.0f);
        }
        
        LONDONER.bind();
        float x = Utils.interpolate(ent.getLastX(), ent.getX(), lag);
        float y = Utils.interpolate(ent.getLastY(), ent.getY(), lag);
        
        float m1;
        float m2;
        if(ent.getFace() == Face.LEFT)
        {
            m1 = 64.0f;
            m2 = 0.0f;
        }
        else
        {
            m1 = 0.0f;
            m2 = 64.0f;
        }
        Shader.getTextureRenderer().drawRectangle(
                x + ox + m1, y,
                x + ox + m2, y + 64.0f, 
                tx, ty, 
                tx + 0.125f, ty + 0.125f);
        
        if(ent.getHealth().wasHurt() || ent.getHealth().wasHealed())
        {
            Shader.setColorEnabled(false);
            Shader.setMixColorEnabled(false);
        }
    }
    
    @Override
    public void onCollideWithTile(Location loc, Face face)
    {
        if(hasRedEyes())
        {
            if(face.getOpposite() == ent.getFace() && ent.getMotionX() == 0.0f)
            {
                ent.getMovement().jump();
            }
        }
        else
        {
            if(loc.getTile().shouldAiUseCollisionBox(loc.getX(), loc.getY()))
            {
                switch(face)
                {
                    case LEFT:
                        direction = Face.LEFT;
                        break;
                    case RIGHT:
                        direction = Face.RIGHT;
                        break;
                }
            }
        }
    }

    @Override
    public void onCollideWithEntity(Entity ent, Face face)
    {
        if(ent.getItemCollector().isHero() && hasRedEyes())
        {
            ent.getHealth().addHealthPercent(-0.1f);
            
            ent.setMotionY(ent.getMotionY() - 20.0f);
            
            float hx = ent.getLevel().getHero().getCenterX();
            if(hx < ent.getCenterX())
            {
                ent.setMotionX(ent.getMotionX() - 10.0f);
            }
            else
            {
                ent.setMotionX(ent.getMotionX() + 10.0f);
            }
        }
    }
}