// CubeApplet.java
// (c)1999 David Barr -- davidbarr@iname.com

import java.applet.*;
import java.awt.event.*;
import java.awt.*;
import java.util.*;
import java.text.*;

class Facelet extends Polygon {
    int n; // facelet number
    int puzzleX, puzzleY;
    int myx[];
    int myy[];
    
    Facelet(int nn,
	    int inx, int iny, int outx, int outy,
	    int x1, int y1,
	    int x2, int y2,
	    int x3, int y3,
	    int x4, int y4) {
//  	System.out.println("(" + x1 + "," + y1 + ")," +
//  			   "(" + x2 + "," + y2 + ")," +
//  			   "(" + x3 + "," + y3 + ")," +
//  			   "(" + x4 + "," + y4 + ")");
	puzzleX=inx;
	puzzleY=iny;
	n = nn;
	myx = new int[4];
	myy = new int[4];
	myx[0] = x1;
	myx[1] = x2;
	myx[2] = x3;
	myx[3] = x4;
	myy[0] = y1;
	myy[1] = y2;
	myy[2] = y3;
	myy[3] = y4;
	resize(outx, outy);
    }

    void resize(int outx, int outy) {
	npoints=0;
	addPoint(myx[0]*outx/puzzleX, myy[0]*outy/puzzleY);
	addPoint(myx[1]*outx/puzzleX, myy[1]*outy/puzzleY);
	addPoint(myx[2]*outx/puzzleX, myy[2]*outy/puzzleY);
	addPoint(myx[3]*outx/puzzleX, myy[3]*outy/puzzleY);
    }
}

class SliceMove {
    int size;
    int moves[][];

    SliceMove(int s) {
	size = s;

	moves = new int[s][4];
    }

    void set(int n, int m, int val) {
	moves[n][m] = val;
    }

    int get(int n, int m) {
	return moves[n][m];
    }

    int getSize() {
	return size;
    }
}

class Cube {
    Facelet facelets[];
    int nfacelets, order, nfaces;
    Color faceColors[];
    SliceMove SliceMoves[][];
    Applet a;

    int puzzleWidth, puzzleHeight, panelWidth=0, panelHeight=0;
    int[] slicePart(int face, int num, boolean horiz, boolean forward) {
	int part[], base, i, r, c, dr, dc;

	part = new int[order];
	base = face * order * order;
	if(horiz) {
	    if(forward) {
		r=num;
		c=0;
		dr=0;
		dc=1;
	    } else {
		r=num;
		c=order-1;
		dr=0;
		dc=-1;
	    }
	} else {
	    if(forward) {
		r=0;
		c=num;
		dr=1;
		dc=0;
	    } else {
		r=order-1;
		c=num;
		dr=-1;
		dc=0;
	    }
	}
	for(i=0; i<order; i++) {
	    part[i] = base + r * order + c;
	    r += dr;
	    c += dc;
	}
	return part;
    }

    void printLegend() {
	int i, j, k;
	DecimalFormat mydf;

	mydf = new DecimalFormat();
	mydf.setMinimumIntegerDigits(3);
	for(k=0; k<order; k++) {
	    for(i=0; i<order; i++) {
		System.out.print("    ");
	    }
	    for(i=0; i<=0; i++) {
		for(j=0; j<order; j++) {
		    System.out.print(mydf.format(i*order*order+k*order+j) + " ");
		}
	    }
	    System.out.print("\n");
	}
	for(k=0; k<order; k++) {
	    for(i=1; i<=4; i++) {
		for(j=0; j<order; j++) {
		    System.out.print(mydf.format(i*order*order+k*order+j) + " ");
		}
	    }
	    System.out.print("\n");
	}
	for(k=0; k<order; k++) {
	    for(i=0; i<order; i++) {
		System.out.print("    ");
	    }
	    for(i=5; i<=5; i++) {
		for(j=0; j<order; j++) {
		    System.out.print(mydf.format(i*order*order+k*order+j) + " ");
		}
	    }
	    System.out.print("\n");
	}
    }

    void makeTables() {
	int slice, i, j, k, l, axis, sliceParts[][], extra=0, size, nrings, ringsize;
	int cycleno, row=0, col=0, face;

	sliceParts = new int[4][];
	SliceMoves = new SliceMove[3][order];

	// compute the number of cycles when a side face turns
	nrings = order/2;
	for(i=0; i<nrings; i++) {
	    ringsize=order-2*i-1;
	    extra += ringsize;
	}

	for(axis=0; axis<3; axis++) { // do this for U, R, F
	    for(slice=0; slice<order; slice++) {
		size = order;
		if(slice == 0 || slice == order-1) {
		    // the outer slices have extra cycles because the
		    // facelets on the sides turn with the slice.
		    size += extra;
		}
		SliceMoves[axis][slice] = new SliceMove(size);
		face = -1;
		switch(axis) {
		case 0: //U
		    if(slice==0) {
			face = 0; //U
		    } else if(slice == order-1) {
			face = 5; //D
		    }
		    sliceParts[0] = slicePart(4,slice,true,false);
		    sliceParts[1] = slicePart(3,slice,true,false);
		    sliceParts[2] = slicePart(2,slice,true,false);
		    sliceParts[3] = slicePart(1,slice,true,false);
		    break;
		case 1: //R
		    if(slice==0) {
			face = 3; //R
		    } else if(slice == order-1) {
			face = 1; //L
		    }
		    sliceParts[0] = slicePart(5,order-slice-1,false,false);
		    sliceParts[1] = slicePart(2,order-slice-1,false,false);
		    sliceParts[2] = slicePart(0,order-slice-1,false,false);
		    sliceParts[3] = slicePart(4,slice,false,true);
		    break;
		case 2: //F
		    if(slice==0) {
			face = 2; //F
		    } else if(slice == order-1) {
			face = 4; //B
		    }
		    sliceParts[0] = slicePart(0,order-slice-1,true,true);
		    sliceParts[1] = slicePart(3,slice,false,true);
		    sliceParts[2] = slicePart(5,slice,true,false);
		    sliceParts[3] = slicePart(1,order-slice-1,false,false);
		    break;
		}
		for(cycleno=0; cycleno<order; cycleno++) {
		    for(j=0; j<4; j++) {
			SliceMoves[axis][slice].set(cycleno, j,
						    sliceParts[j][cycleno]);
		    }
		}
  		if(slice == 0 || slice == order-1) {
  		    for(i=0; i<nrings; i++) {
			ringsize=order-2*i-1;
			for(k=0; k<ringsize; k++) {
			    for(j=0; j<4; j++) {
				if(slice==0) {
				    l = j;
				} else {
				    l = 3 - j;
				}
				switch(l) {
				case 0:
				    row=i;
				    col=i+k;
				    break;
				case 1:
				    col=order-1-i;
				    row=i+k;
				    break;
				case 2:
				    row=order-1-i;
				    col=order-1-i-k;
				    break;
				case 3:
				    col=i;
				    row=order-1-i-k;
				    break;
				}
				SliceMoves[axis][slice].set(cycleno, j,
							    face*order*order+row*order+col);
			    }
			    cycleno++;
  			}
  		    }
  		}
	    }
	}
    }

    void printTables() {
	int axis, slice, j, k;

	for(axis=0; axis<3; axis++) {
	    for(slice=0; slice<order; slice++) {
		System.out.print("{");
		for(j=0; j<SliceMoves[axis][slice].getSize(); j++) {
		    if(j>0) {
			System.out.print(",");
		    }
		    System.out.print("{");
		    for(k=0; k<4; k++) {
			if(k>0) {
			    System.out.print(",");
			}
			System.out.print(SliceMoves[axis][slice].get(j,k));
		    }
		    System.out.print("}");
		}
		System.out.print("},\n");
	    }
	    System.out.print("\n");
	}
    }

    public Cube(int inOrder, Applet a) {
	order = inOrder;
	puzzleWidth = order*order*4+1;
	puzzleHeight = order*order*5+1;
	panelWidth = 0;
	panelHeight = 0;
	restore(a);
	makeTables();
//      	printLegend();
//        	printTables();
    }

    void restore(Applet a) {
	int i, j, k, row, col, n=0, sizex[], indentx[], indenty[], sizey[];
	
	nfaces = 6; // cube
	nfacelets = order*order*nfaces;
	facelets = new Facelet[nfacelets];

	faceColors = new Color[nfaces];
	//	faceColors[0] = Color.red;
	//	faceColors[1] = Color.green;
	//	faceColors[2] = Color.blue;
	//	faceColors[3] = Color.yellow;
	//	faceColors[4] = Color.white;
	//	faceColors[5] = Color.orange;
	faceColors[Integer.parseInt(a.getParameter("wheresr"))] = Color.red;
	faceColors[Integer.parseInt(a.getParameter("wheresg"))] = Color.green;
	faceColors[Integer.parseInt(a.getParameter("wheresb"))] = Color.blue;
	faceColors[Integer.parseInt(a.getParameter("wheresy"))] = Color.yellow;
	faceColors[Integer.parseInt(a.getParameter("wheresw"))] = Color.white;
	faceColors[Integer.parseInt(a.getParameter("whereso"))] = Color.orange;

  	indentx = new int[order+1];
  	indenty = new int[order+1];
  	sizex   = new int[order+1];
  	sizey   = new int[order+1];

	for(k=0; k<nfaces; k++) {
	    for(i=0; i<order+1; i++) {
		switch(k) {
		case 0: //U
		    sizex  [i] = order*4-2*i;
		    sizey  [i] = order;
		    indentx[i] = order*i;
		    indenty[i] = order*order;
		    break;
		case 1: //L
		    sizex  [i] = order;
		    sizey  [i] = order*4-2*i;
		    indentx[i] = 0;
		    indenty[i] = order*order+order*i;
		    break;
		case 2: //F
		    sizex  [i] = 2*order;
		    sizey  [i] = 2*order;
		    indentx[i] = order*order;
		    indenty[i] = 2*order*order;
		    break;
		case 3: //R
		    sizex  [i] = order;
		    sizey  [i] = 2*order+2*i;
		    indentx[i] = 3*order*order;
		    indenty[i] = 2*order*order-order*i;
		    break;
		case 4: //B
		    sizex  [i] = order * -4; // this is weird to match the move tables
		    sizey  [i] = order * -1;
		    indentx[i] = order*sizex[i]*-1;
		    indenty[i] = order*sizey[i]*-1;
		    break;
		case 5: //D
		    sizex  [i] = 2*order+2*i;
		    sizey  [i] = order;
		    indentx[i] = order*order-order*i;
		    indenty[i] = order*order*4;
		    break;
		}
	    }
	    for(row=0; row<order; row++) {
		for(col=0; col<order; col++) {
		    facelets[n] =
			new Facelet(n,
				    puzzleWidth, puzzleHeight,
				    panelWidth, panelHeight,
				    col    *sizex[row]  +indentx[row],
				    row    *sizey[col]  +indenty[col],

				    (col+1)*sizex[row]  +indentx[row],
				    row    *sizey[col+1]+indenty[col+1],

				    (col+1)*sizex[row+1]+indentx[row+1],
				    (row+1)*sizey[col+1]+indenty[col+1],

				    col    *sizex[row+1]+indentx[row+1],
				    (row+1)*sizey[col]  +indenty[col]);
		    n++;
		}
	    }
	}
    }

    void paint(Graphics g, int panelWidthNew, int panelHeightNew) {
	int i;
	Facelet f;
	
	for(i=0; i<nfacelets; i++) {
	    f = facelets[i];
	    if(f == null) {
		continue;
	    }
	    if(panelWidth != panelWidthNew ||
	       panelHeight != panelHeightNew) {
		if(panelWidthNew*5/4 > panelHeightNew) {
		    panelWidthNew = panelHeightNew*4/5;
		} else {
		    panelHeightNew = panelWidthNew*5/4;
		}
		f.resize(panelWidthNew, panelHeightNew);
	    }
	    g.setColor(faceColors[f.n / (order*order)]);
	    g.fillPolygon(f);
	    g.setColor(Color.black);
	    g.drawPolygon(f);
	}
	panelWidth = panelWidthNew;
	panelHeight = panelHeightNew;
    }

    void TurnSlice(int axis, int slice, int times) {
	int i, j, k, l;
	for(l=0; l<times; l++) {
	    for(i=0; i<SliceMoves[axis][slice].getSize(); i++) {
		k = facelets[SliceMoves[axis][slice].get(i,3)].n;
		for(j=3; j>=1; j--) {
		    facelets[SliceMoves[axis][slice].get(i,j)].n =
			facelets[SliceMoves[axis][slice].get(i,j-1)].n;
		}
		facelets[SliceMoves[axis][slice].get(i,0)].n = k;
	    }
	}
    }

    void DetermineAndTurnSlice(int facelet1, int facelet2, boolean allSlices) {
	int f[], grps[], ns[], Slice, count, fl, grp, n, turns, i, axis;
	int firstSlice, lastSlice;

	ns   = new int[2];
	grps = new int[2];
	f    = new int[2];
	f[0] = facelet1;
	f[1] = facelet2;

//  	System.out.println("clicked on " + f[0] + " and " + f[1]);

	for(axis=0; axis<3; axis++) {
	    for(Slice=0; Slice<order; Slice++) {
		count=0;
		for(fl = 0; fl<2; fl++) {
		    // only look at the cycles for the outer facelets
		    for(grp=0; grp<order; grp++) {
			for(n=0; n<4; n++) {
			    if(SliceMoves[axis][Slice].get(grp,n) == f[fl]) {
				ns[fl] = n;
				grps[fl] = grp;
				count++;
			    }
			}
		    }
		}
		if(count == 2) {
//    		    System.out.println("Facelets are in axis " + axis +
//  				       ", slice " + Slice);
		    turns = (ns[1]-ns[0])%4;
		    if(turns<0) {
			turns += 4;
		    }
		    if(turns == 0) {
			turns = grps[1]-grps[0];
			if(turns < 0) {
			    turns = 3;
			} else {
			    turns = 1;
			}
		    }
		    if(allSlices) {
			firstSlice = 0;
			lastSlice = order-1;
		    } else {
			firstSlice = lastSlice = Slice;
		    }
		    for(i=firstSlice; i<=lastSlice; i++) {
			TurnSlice(axis, i, turns);
		    }
		    return;
		} else {
//  		    System.out.println(axis + ", " + Slice + ": " + count);
		}
	    }
	}
    }
    
    int whichFacelet(Point p) {
	int i;
	for(i=0; i<nfacelets; i++) {
	    if(facelets[i].contains(p)) {
		return i;
	    }
	}
	return -1;
    }

    void scramble() {
	int i;
	Random r;

	r = new Random();
	for(i=0; i<100; i++) {
	    TurnSlice(Math.abs(r.nextInt())%3,
		      Math.abs(r.nextInt())%order,
		      (Math.abs(r.nextInt())%2)*2+1);
	}
    }
}

class CubePanel extends Panel implements MouseListener, KeyListener {
    Cube myCube;
    int pressed, released, order;
    Applet a;

    CubePanel(int orderX, Applet applet) {
	a = applet;
//  	System.out.println("width  = " + (order*order*scale*4+1));
//  	System.out.println("height = " + (order*order*scale*5+1));
	order = orderX;
	myCube = new Cube(order, a);
	addMouseListener(this);
	addKeyListener(this);
    }

    public void destroy() {
	myCube = null;
	removeMouseListener(this);
	removeKeyListener(this);
    }

    public void paint(Graphics g) {
	myCube.paint(g, getSize().width, getSize().height);
    }

    //The following empty methods can be removed
    //by implementing a MouseAdapter (usually done
    //using an inner class).
    public void mouseClicked(MouseEvent event) {
    }

    public void mouseEntered(MouseEvent event) {
    }

    public void mouseExited(MouseEvent event) {
    }

    public void mousePressed(MouseEvent event) {
	pressed = myCube.whichFacelet(event.getPoint());
    }

    public void mouseReleased(MouseEvent event) {
	boolean allSlices;

	allSlices = event.isShiftDown();
	released = myCube.whichFacelet(event.getPoint());
	if(pressed != released) {
	    myCube.DetermineAndTurnSlice(pressed, released, allSlices);
	    repaint();
	}
    }

    public void keyTyped(KeyEvent e) {
	//System.out.println(e);
	char c = e.getKeyChar();
	switch(c) {
	case 'r':
	case 'R':
	    myCube.restore(a);
	    repaint();
	    break;
	case 's':
	case 'S':
	    myCube.scramble();
	    repaint();
	    break;
	case '+':
	    order++;
	    myCube = new Cube(order, a);
	    repaint();
	    break;
	case '-':
	    if(order>1) {
		order--;
	    }
	    myCube = new Cube(order, a);
	    repaint();
	    break;
	case 'l':
	    myCube.printLegend();
	    break;
	case 't':
	    myCube.printTables();
	    break;
	}

    }

    public void keyPressed(KeyEvent e) {}
    public void keyReleased(KeyEvent e) {}
}

class StartButton extends Button implements ActionListener {
    Applet a;

    StartButton(Applet applet) {
	super("Start");
	a = applet;
	addActionListener(this);
    }

    public void actionPerformed(ActionEvent e) {
	Frame f = new Frame("Java Cube");

	class WCloser extends WindowAdapter {
	    Window w;

	    WCloser(Window w1) {
		w = w1;
	    }
	    
	    public void windowClosing(WindowEvent e) {
		w.removeAll();
		w.dispose();
	    }
	}

	f.addWindowListener(new WCloser(f));
	f.setSize(200, 250);
	f.add(new CubePanel(3, a));
	f.show();
    }
}

public class CubeApplet extends Applet {
    public void init() {
      setLayout(new BorderLayout());
      add(new StartButton(this), BorderLayout.CENTER);
    }
}