// Decompiled by Jad v1.5.7f. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   BoggleGrid.java

import java.awt.*;
import java.awt.event.*;
import java.io.PrintStream;
import java.io.Serializable;
import java.util.Stack;
import java.util.Vector;
import javax.swing.*;

public class BoggleGrid extends JPanel
    implements MouseListener, Serializable
{

    BoggleGrid(int i)
    {
        int l = 0;
        gridNumber = i;
        setLayout(null);
        grid = new BoggleCube[4][4];
        for(int j = 0; j < 4; j++)
        {
            for(int k = 0; k < 4; k++)
            {
                grid[k][j] = new BoggleCube(cubes[l++]);
                add(grid[k][j]);
                grid[k][j].reshape(4 + j * (grid[k][j].getPreferredSize().width + 4), 4 + k * (grid[k][j].getPreferredSize().height + 4), grid[k][j].getPreferredSize().width, grid[k][j].getPreferredSize().height);
                grid[k][j].addMouseListener(this);
                grid[k][j].setUsable(true);
            }

        }

        setSize((grid[0][0].getPreferredSize().width + 4) * 4 + 4, (grid[0][0].getPreferredSize().height + 4) * 4 + 4);
        word = new Stack();
    }

    private void defaultState()
    {
        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
            {
                if(grid[i][j].isUsed())
                    grid[i][j].toggleUsed();
                grid[i][j].setUsable(true);
            }

        }

    }

    public String getCube(int i, int j)
    {
        return grid[i][j].getTop();
    }

    public int getGridNumber()
    {
        return gridNumber;
    }

    public static void main(String args[])
    {
        BoggleGrid bogglegrid = new BoggleGrid(-1);
        System.out.println("New grid");
        System.out.println(bogglegrid);
        for(int i = 0; i < 5; i++)
        {
            System.out.println("Shaken grid");
            bogglegrid.shake();
            System.out.println(bogglegrid);
        }

    }

    public void mouseClicked(MouseEvent mouseevent)
    {
    }

    public void mouseEntered(MouseEvent mouseevent)
    {
        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
                if(mouseevent.getComponent() == grid[i][j])
                    grid[i][j].mouseEntered();

        }

    }

    public void mouseExited(MouseEvent mouseevent)
    {
        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
                if(mouseevent.getComponent() == grid[i][j])
                    grid[i][j].mouseExited();

        }

    }

    public void mousePressed(MouseEvent mouseevent)
    {
        if(mouseevent.getModifiers() == 16)
            tileSelected(mouseevent);
        if(mouseevent.getModifiers() == 4)
            submitWord();
    }

    public void mouseReleased(MouseEvent mouseevent)
    {
    }

    public void paintComponent(Graphics g)
    {
        g.setColor(Color.orange);
        g.fillRoundRect(0, 0, (grid[0][0].getPreferredSize().width + 4) * 4 + 4, (grid[0][0].getPreferredSize().height + 4) * 4 + 4, 10, 10);
    }

    public void setEnabled(boolean flag)
    {
        super.setEnabled(flag);
        if(!flag)
        {
            for(int i = 0; i < 4; i++)
            {
                for(int j = 0; j < 4; j++)
                {
                    if(grid[i][j].isUsed())
                        grid[i][j].toggleUsed();
                    grid[i][j].setUsable(false);
                    grid[i][j].removeMouseListener(this);
                }

            }

            repaint();
        }
    }

    public void setScoring(Score score1)
    {
        score1.setGridNumber(gridNumber);
        score = score1;
    }

    public void shake()
    {
        for(int i = 0; i < 4; i++)
        {
            for(int k = 0; k < 4; k++)
                grid[i][k].shake();

        }

        for(int j = 0; j < 4; j++)
        {
            for(int l = 0; l < 4; l++)
            {
                int j1 = (int)Math.round(Math.random() * 3D);
                int l1 = (int)Math.round(Math.random() * 3D);
                BoggleCube bogglecube = grid[j1][l1];
                grid[j1][l1] = grid[j][l];
                grid[j][l] = bogglecube;
            }

        }

        for(int i1 = 0; i1 < 4; i1++)
        {
            for(int k1 = 0; k1 < 4; k1++)
                grid[k1][i1].reshape(4 + i1 * (grid[k1][i1].getPreferredSize().width + 4), 4 + k1 * (grid[k1][i1].getPreferredSize().height + 4), grid[k1][i1].getPreferredSize().width, grid[k1][i1].getPreferredSize().height);

        }

    }

    private void submitWord()
    {
        StringBuffer stringbuffer = new StringBuffer();
        BoggleCube bogglecube;
        for(; !word.isEmpty(); stringbuffer.insert(0, bogglecube.getTop()))
            bogglecube = (BoggleCube)word.pop();

        try
        {
            score.submitWord(new String(stringbuffer));
        }
        catch(WordAlreadyUsed _ex)
        {
            JOptionPane.showMessageDialog(this, "You have already used that word once!", "Bad word submission", 0);
        }
        catch(WordNotKnown _ex)
        {
            JOptionPane.showMessageDialog(this, "That word does not exist!", "Bad word submission", 0);
        }
        catch(WordTooShort _ex)
        {
            JOptionPane.showMessageDialog(this, "Submitted words must be of at least 3 letter to gain scoring!", "Bad word submission", 0);
        }
        finally
        {
            defaultState();
        }
    }

    private void tileSelected(MouseEvent mouseevent)
    {
        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
                if(mouseevent.getComponent() == grid[i][j])
                {
                    if(!grid[i][j].isUsed())
                    {
                        if(!grid[i][j].isUsable())
                            return;
                        grid[i][j].toggleUsed();
                        word.push(grid[i][j]);
                    } else
                    if(word.peek() == grid[i][j])
                    {
                        grid[i][j].toggleUsed();
                        word.pop();
                        if(!word.isEmpty())
                        {
                            for(int k = 0; k < 4; k++)
                            {
                                for(int i1 = 0; i1 < 4; i1++)
                                    if(word.peek() == grid[k][i1])
                                    {
                                        i = k;
                                        j = i1;
                                    }

                            }

                        } else
                        {
                            defaultState();
                            return;
                        }
                    } else
                    {
                        return;
                    }
                    for(int l = 0; l < 4; l++)
                    {
                        for(int j1 = 0; j1 < 4; j1++)
                            if(!grid[l][j1].isUsed() && Math.abs(i - l) <= 1 && Math.abs(j - j1) <= 1)
                                grid[l][j1].setUsable(true);
                            else
                                grid[l][j1].setUsable(false);

                    }

                    return;
                }

        }

    }

    public String toString()
    {
        String s = "Grid #" + gridNumber + "\n";
        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
                s = s + " " + grid[i][j].getTop();

            s = s + "\n";
        }

        s = s + "\n";
        return s;
    }

    private BoggleCube grid[][];
    private static String cubes[][] = {
        {
            "F", "S", "K", "F", "P", "A"
        }, {
            "I", "E", "R", "L", "D", "X"
        }, {
            "O", "I", "S", "S", "T", "E"
        }, {
            "E", "U", "S", "E", "N", "I"
        }, {
            "T", "S", "T", "I", "D", "Y"
        }, {
            "B", "J", "O", "O", "A", "B"
        }, {
            "C", "M", "U", "O", "T", "I"
        }, {
            "E", "E", "H", "N", "G", "W"
        }, {
            "V", "Y", "R", "D", "E", "L"
        }, {
            "I", "U", "N", "H", "Qu", "M"
        }, {
            "O", "T", "W", "O", "A", "T"
        }, {
            "O", "S", "C", "A", "P", "H"
        }, {
            "L", "R", "Y", "T", "E", "T"
        }, {
            "T", "H", "R", "V", "E", "W"
        }, {
            "G", "E", "E", "N", "A", "A"
        }, {
            "H", "N", "L", "N", "Z", "R"
        }
    };
    private Stack word;
    private Score score;
    private int gridNumber;

}