/*
 * Ristipolku
 * (C) Copyright 2011 Matti 'ccr' Hämäläinen <ccr@tnsp.org>
 */
package game;

import java.awt.*;
import java.awt.geom.*;
import java.util.*;
import java.math.*;


public class Piece
{
    static final int numConnections = 8;
    static final float maxTime = 50.0f;

    int currRotation;
    int[] connections;
    boolean[] active;
    PieceType type, oldType;

    boolean rotationChanged, rotationActive,
            typeChanged, typeActive,
            activeChanged, activeActive;
    float currAngle, newAngle, rotationTime, typeTime;
    float throb;

    Interpolate lerpRotation;

    public Piece(PieceType ptype)
    {
        // Initialize
        connections = new int[numConnections];
        active = new boolean[numConnections];
        type = ptype;

        rotationChanged = false;
        rotationActive = false;
        currRotation = 0;
        currAngle = 0;

        typeChanged = false;
        typeActive = false;
      
        throb = 0;


        // Initialize connections between endpoints of the paths inside the piece
        for (int i = 0; i < numConnections; i++)
            connections[i] = -1;


        // Randomize connections in the piece
        Random rnd = new Random();
        for (int i = 0; i < numConnections; i++)
        {
            while (connections[i] < 0)
            {
                int tmp = rnd.nextInt(numConnections);
                if (tmp != i && connections[tmp] < 0)
                {
                    connections[i] = tmp;
                    connections[tmp] = i;
                }
            }
        }
    }

    public Piece()
    {
        this(PieceType.NONE);
    }

    public void setType(PieceType ptype)
    {
        typeChanged = (oldType != ptype);
        oldType = type;
        type = ptype;
    }

    public int getConnection(int in)
    {
        return connections[in];
    }

    public void rotate(boolean dir)
    {
        // Only normal 
        if (type != PieceType.LOCKED && type != PieceType.ACTIVE)
            return;

        currRotation = (currRotation + (dir ? 1 : -1)) % 4;
        newAngle = (float) ((currRotation * Math.PI) / 2.0f);
        lerpRotation = new Interpolate(newAngle, currAngle, maxTime);
        rotationChanged = true;
    }

    public Point2D getPointCoords(float x, float y, float dim, int index)
    {
        float ox = 0, oy = 0;
        float step = dim / 10;
      
        switch (index) {
            case  0: ox = 3.0f; oy = 0.5f; break;
            case  1: ox = 7.0f; oy = 0.5f; break;
            case  2: ox = 9.5f; oy = 3.0f; break;
            case  3: ox = 9.5f; oy = 7.0f; break;
            case  4: ox = 7.0f; oy = 9.5f; break;
            case  5: ox = 3.0f; oy = 9.5f; break;
            case  6: ox = 0.5f; oy = 7.0f; break;
            case  7: ox = 0.5f; oy = 3.0f; break;

            case -1: ox = 5.0f; oy = 5.0f; break;
        }

        return new Point2D.Float(x + ox * step, y + oy * step);
    }

    public void setActiveConnection(int index)
    {
        active[index] = true;
        activeChanged = true;
    }

    public void animate(float time)
    {
        if (rotationChanged)
        {
            rotationTime = time;
            rotationActive = true;
            rotationChanged = false;
        }

        if (rotationActive)
        {
            float t = (time - rotationTime) / 2;

            if (t < maxTime)
                currAngle = lerpRotation.getValue(t);
            else
            {
                currAngle = newAngle;
                rotationActive = false;
            }
        }
        
        if (typeChanged)
        {
            typeTime = time;
            typeActive = true;
            typeChanged = false;
        }
        
        if (typeActive)
        {
        }
        
        if (activeChanged)
        {
        }
        
        throb = (time % 100) / 100.0f;
    }

    public void paint(Graphics2D g, float x, float y, float dim)
    {
        g.rotate(currAngle, x + dim / 2.0f, y + dim / 2.0f);

        switch (type) {
            case LOCKED:  g.setPaint(Color.green); break;
            case ACTIVE:  g.setPaint(Color.red); break;
            case START:   g.setPaint(Color.orange); break;
        }

        g.fill(new RoundRectangle2D.Float(x, y, dim, dim, dim / 10, dim / 10));

        g.setPaint(Color.black);
        g.setStroke(new BasicStroke(4.0f));
        g.draw(new RoundRectangle2D.Float(x, y, dim, dim, dim / 10, dim / 10));

        if (type == PieceType.START)
            return;

        if (type == PieceType.ACTIVE)
        {
            float offs1 = throb * 10.0f,
                  offs2 = throb * 20.0f;

            g.setPaint(new Color(0.0f, 0.0f, 0.0f, (float) (1.0f - throb) ));
            g.setStroke(new BasicStroke(2.0f + throb * 2.0f));
            g.draw(new RoundRectangle2D.Float(x - offs1, y - offs1, dim + offs2, dim + offs2, dim / 10, dim / 10));
        }

        g.setPaint(Color.black);
        g.setStroke(new BasicStroke(6.0f));
//      CubicCurve2D c = new CubicCurve2D.Float();
        QuadCurve2D c = new QuadCurve2D.Float();
        boolean[] drawn = new boolean[numConnections];
        for (int i = 0; i < numConnections; i++)
        if (!drawn[i])
        {
            Point2D start, cp1, cp2, end;
            
            start = getPointCoords(x, y, dim, i);
            end   = getPointCoords(x, y, dim, connections[i]);
            cp1   = getPointCoords(x, y, dim, -1);

            c.setCurve(start, cp1, end);
            g.draw(c);

            drawn[i] = true;
            drawn[connections[i]] = true;
        }
    }
}