package cz.xelfi.quoridor.visidor;

 import cz.xelfi.quoridor.Board;

 import cz.xelfi.quoridor.Fence;

 import cz.xelfi.quoridor.Fence.Orientation;

 import cz.xelfi.quoridor.IllegalPositionException;

 import cz.xelfi.quoridor.Move;

 import cz.xelfi.quoridor.Player;

 import java.awt.Color;

 import java.awt.Graphics2D;

 import java.awt.Point;

 import java.awt.Rectangle;

 import javax.swing.JFrame;

 import javax.swing.JPanel;

 import org.netbeans.api.visual.action.MoveProvider;

 import org.netbeans.api.visual.border.BorderFactory;

 import org.netbeans.api.visual.widget.ImageWidget;

 import org.netbeans.api.visual.widget.LayerWidget;

 import org.netbeans.api.visual.widget.Scene;

 import org.netbeans.api.visual.widget.Widget;

 import org.openide.util.Exceptions;

 /**

  *

  * @author Jaroslav Tulach <jtulach@netbeans.org>

  */

 final class Viewer extends JPanel {

     private Board board;

     private final Scene scene;

     public Viewer() {

         this(Board.empty());

     }

     private Viewer(Board b) {

         this.board = b;

         this.scene = new Scene();

         add(scene.createView());

         view(scene, board);

     }

     /**

      * @param args the command line arguments

      */

     public static void main(String[] args) throws IllegalPositionException {

         Board b = Board.empty();

         for (int i = 1; i <= 8; i++) {

             b = b.apply(Move.fence('A', i, Orientation.values()[i % 2]));

         }

         for (int i = 1; i <= 8; i++) {

             b = b.apply(Move.fence('H', i, Orientation.values()[(i + 1) % 2]));

         }

         JFrame f = new JFrame();

         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         f.add(new Viewer(b));

         f.pack();

         f.setVisible(true);

     }

     private void view(Scene scene, Board b) {

         scene.removeChildren();

         drawBoard(scene, b);

     }

     static void drawBoard(Scene scene, Board b) {

 //        Scene layerBoard = scene;

         scene.setPreferredLocation(new Point(0, 0));

         final LayerWidget layerLines = new LayerWidget(scene);

         scene.addChild(layerLines);

         final LayerWidget layerBoard = new LayerWidget(scene);

         layerLines.addChild(layerBoard);

         final int WDTH = 50;

         final int HGHT = 50;

         for (int i = 0; i < 9; i++) {

             for (int j = 0; j < 9; j++) {

                 Widget w = new FieldWidget(scene);

                 w.setPreferredBounds(new Rectangle(i * WDTH, j * HGHT, WDTH, HGHT));

                 layerBoard.addChild(w);

             }

         }

 /*

         ImageWidget horizontalWall = new ImageWidget(scene);

         horizontalWall.setPreferredBounds(new Rectangle(550, 300, 90, 10));

         horizontalWall.setBackground(Color.BLACK);

         horizontalWall.getActions().addAction(ActionFactory.createMoveAction(null, new MoveControl(true)));

         horizontalWall.setBorder(BorderFactory.createLineBorder());

         horizontalWall.setOpaque(true);

         layerBoard.addChild(horizontalWall);

         ImageWidget verticalWall = new ImageWidget(scene);

         verticalWall.setPreferredBounds(new Rectangle(600, 150, 10, 90));

         verticalWall.setBackground(Color.BLACK);

         verticalWall.getActions().addAction(ActionFactory.createMoveAction(null, new MoveControl(false)));

         verticalWall.setBorder(BorderFactory.createLineBorder());

         verticalWall.setOpaque(true);

         layerBoard.addChild(verticalWall);

 */

         for (Fence f : b.getFences()) {

             Rectangle r = fenceRectangle(f.getColumn(), f.getRow(), f.getOrientation());

             ImageWidget fenceWall = new ImageWidget(scene);

             fenceWall.setPreferredBounds(r);

             fenceWall.setBackground(Color.BLACK);

             fenceWall.setBorder(BorderFactory.createLineBorder());

             fenceWall.setOpaque(true);

             layerBoard.addChild(fenceWall);

         }

         int cnt = 0;

         Color[] colors = { Color.WHITE, Color.BLACK, Color.ORANGE, Color.MAGENTA };

         for (Player p : b.getPlayers()) {

             PlayerWidget pw = new PlayerWidget(scene, colors[cnt]);

             pw.setPreferredBounds(new Rectangle(p.getColumn() * WDTH, p.getRow() * HGHT, WDTH, HGHT));

             layerBoard.addChild(pw);

             cnt++;

         }

     }

     private static Rectangle fenceRectangle(char column, int row, Fence.Orientation o) {

         int w, h;

         switch (o) {

             case HORIZONTAL: w = 45; h = 5; break;

             case VERTICAL: w = 5; h = 45; break;

             default: throw new IllegalStateException();

         }

         return new Rectangle(

             (column - 'A' + 1) * 50 - w, row * 50 - h, 2 * w, 2 * h

         );

     }

     private class MoveControl implements MoveProvider {

         final boolean horizontal;

         Point orig;

         private MoveControl(boolean horizontal) {

             this.horizontal = horizontal;

         }

         public void movementStarted(Widget widget) {

             System.err.println("started: " + widget.getBounds());

         }

         public void movementFinished(Widget widget) {

             try {

                 final Rectangle bounds = widget.getBounds();

                 final Move m = createMoveForDrop( bounds);

                 System.err.println("finish: " + m);

                 board = board.apply(m);

             } catch (IllegalPositionException ex) {

                 Exceptions.printStackTrace(ex);

             }

             view(scene, board);

         }

         public Point getOriginalLocation(Widget widget) {

             final Rectangle b = widget.getBounds();

             orig = new Point(b.x, b.y);

             try {

                 System.err.println("  where: " + createMoveForDrop(b));

             } catch (IllegalPositionException ex) {

                 Exceptions.printStackTrace(ex);

             }

             return orig;

         }

         public void setNewLocation(Widget widget, Point location) {

             final Rectangle b = new Rectangle(

                 round(location.x, true) + (horizontal ? 5 : 0),

                 round(location.y, false) + (horizontal ? 0 : 5),

                 horizontal ? 90 : 10,

                 horizontal ? 10 : 90

             );

             widget.setPreferredBounds(b);

             try {

                 System.err.println("move: " + createMoveForDrop(b));

             } catch (IllegalPositionException ex) {

                 System.err.println("no move");

             }

         }

         Move createMoveForDrop(final Rectangle bounds) throws IllegalPositionException {

             int column = bounds.x / 50;

             int row = bounds.y / 50;

             Orientation o = bounds.width > bounds.height ? Orientation.HORIZONTAL : Orientation.VERTICAL;

             switch (o) {

                 case HORIZONTAL: row--; break;

                 case VERTICAL: column--; break;

                 default: assert false;

             }

             if (column < 0) {

                 column = 0;

             }

             if (column >= 9) {

                 column = 8;

             }

             if (row < 0) {

                 row = 0;

             }

             if (row > 8) {

                 row = 8;

             }

             Move m = Move.fence((char) ('A' + column), 1 + row, o);

             return m;

         }

         int round(int p, boolean cmpHori) {

     //        p = horizontal ? orig.x + p: orig.y + p;

             int onboard = p / 50;

             if (onboard < 0) {

                 onboard = 0;

             }

             if (onboard >= 9) {

                 return p;

             }

             int real = 25 + onboard * 50;

             if (horizontal != cmpHori) {

                 return real - 5;

             } else {

                 return real;

             }

         }

     }

     private static final class PlayerWidget extends Widget {

         private final Color color;

         public PlayerWidget(Scene s, Color color) {

             super(s);

             this.color = color;

         }

         @Override

         protected Rectangle calculateClientArea() {

             return getBounds();

         }

         @Override

         protected void paintWidget() {

             Graphics2D g = getGraphics();

             Rectangle b = getBounds();

             g.setColor(color);

             g.fillOval(b.x + 8, b.y + 8, b.width - 16, b.height - 16);

         }

     }

     private static final class FieldWidget extends Widget {

         public FieldWidget(Scene s) {

             super(s);

         }

         @Override

         protected Rectangle calculateClientArea() {

             return getBounds();

         }

         @Override

         protected void paintWidget() {

             Graphics2D g = getGraphics();

             Rectangle b = getBounds();

             g.setColor(Color.lightGray);

             g.fillRect(b.x + 5, b.y + 5, b.width - 10, b.height - 10);

         }

     }

 }