import java.awt.*;
    import java.awt.event.*;

    import javax.swing.*;
    import javax.swing.border.EmptyBorder;
    import javax.swing.event.*;
    import javax.swing.text.*;

    import java.text.*;

    import java.util.List;
    import java.util.ArrayList;
    import java.util.Arrays;


    @SuppressWarnings("unused")
    public class BuildGridGUI
    {

        static final int WIDTH_MIN = 100;
        static final int WIDTH_MAX = 2000;
        static final int WIDTH_INIT = 520;

        static final int HEIGHT_MIN = 100;
        static final int HEIGHT_MAX = 2000;
        static final int HEIGHT_INIT = 300;

        static final int NUMCOLS_INIT = 3;
        static final int NUMCOLS_MIN = 1;
        static final int NUMCOLS_MAX = 8;

        int widthOfFrames = WIDTH_INIT;
        int heightOfFrames = HEIGHT_INIT;
        int numCols = NUMCOLS_INIT;
        int numFrames;

        List<String> listOfIDs;

        /*
        final static boolean shouldFill = true;
        final static boolean shouldWeightX = true;
        final static boolean RIGHT_TO_LEFT = false;
        */



        private final JComponent makeUI()
        {
            JPanel p = new JPanel();


            p.setLayout(new BorderLayout());

            Grid g = new Grid();
            JComponent j = makeSideMenu(g);

            g.setBorder(BorderFactory.createCompoundBorder(
                  BorderFactory.createLineBorder(Color.red),
                  g.getBorder()));


            j.setBorder(BorderFactory.createCompoundBorder(
                      BorderFactory.createLineBorder(Color.red),
                      j.getBorder()));


            p.add(j, BorderLayout.EAST);
            p.add(g, BorderLayout.WEST);


            return p;
        }

        private final JComponent makeSideMenu(Grid grid)
        {
            JPanel p = new JPanel();

            JSpinner numColsSelectorField = new JSpinner();
            JSpinner widthSpinner = new JSpinner();
            JSlider widthSlider = new JSlider(WIDTH_MIN, WIDTH_MAX, WIDTH_INIT);
            JSlider heightSlider = new JSlider(BuildGridGUI.HEIGHT_MIN, BuildGridGUI.HEIGHT_MAX, BuildGridGUI.HEIGHT_INIT);
            JButton confirmButton = new JButton("Confirm");
            //JLabel widthSlider_Thumb = new JLabel();
            JLabel numColsSelectorLabel = new JLabel("Frames Per Column");
            JLabel widthLabel = new JLabel("Width per Frame (Pixels)");
            JLabel heightLabel = new JLabel("Height per Frame (Pixels)");
            JSpinner heightSpinner = new JSpinner();



            numColsSelectorField.setModel(new SpinnerNumberModel(NUMCOLS_INIT, NUMCOLS_MIN, NUMCOLS_MAX, 1));
            numColsSelectorField.setEditor(new JSpinner.NumberEditor(numColsSelectorField));
            numColsSelectorField.setMaximumSize(numColsSelectorField.getPreferredSize());
            numColsSelectorField.addChangeListener(new ChangeListener() {
                @Override public void stateChanged(ChangeEvent e)
                {
                    JSpinner spinner = (JSpinner)e.getSource();
                    try {
                        spinner.commitEdit();
                    } catch (ParseException e1) {
                        e1.printStackTrace();
                    }
                    setNumCols((Integer)spinner.getValue());
                    grid.refresh();
                }
            });


            widthSlider.setMajorTickSpacing(300);
            widthSlider.setMinorTickSpacing(20);
            widthSlider.setPaintTicks(true);
            widthSlider.setPaintLabels(true);
            widthSlider.addChangeListener(new ChangeListener()
            {
                @Override public void stateChanged(ChangeEvent e)
                {
                    JSlider slider = (JSlider)e.getSource();
                    if (!slider.getValueIsAdjusting())
                    {
                        setWidthOfFrames((Integer)slider.getValue());
                        GatedChangeListener.setEnabled(false);
                        widthSpinner.setValue((Integer)slider.getValue());
                        GatedChangeListener.setEnabled(true);
                        grid.refresh();
                    }
                }
            });

            widthSpinner.setModel(new SpinnerNumberModel(WIDTH_INIT, WIDTH_MIN, WIDTH_MAX, 1));
            widthSpinner.setEditor(new JSpinner.NumberEditor(widthSpinner));
            widthSpinner.setPreferredSize(new Dimension(70, 30));
            widthSpinner.setMaximumSize(widthSpinner.getPreferredSize());
            widthSpinner.addChangeListener(new GatedChangeListener() {
                @Override public void onChangedState(ChangeEvent e)
                {
                    JSpinner spinner = (JSpinner)e.getSource();
                    try {
                        spinner.commitEdit();
                    } catch (ParseException e1) {
                        e1.printStackTrace();
                    }
                    setWidthOfFrames(((Integer)spinner.getValue()));
                    widthSlider.setValue((Integer)spinner.getValue());
                    grid.refresh();
                }
            });




            heightSlider.setMajorTickSpacing(300);
            heightSlider.setMinorTickSpacing(20);
            heightSlider.setPaintTicks(true);
            heightSlider.setPaintLabels(true);
            heightSlider.addChangeListener(new ChangeListener()
            {
                @Override public void stateChanged(ChangeEvent e)
                {
                    JSlider slider = (JSlider)e.getSource();
                    if (!slider.getValueIsAdjusting())
                    {
                        setHeightOfFrames((Integer)slider.getValue());
                        heightSpinner.setValue((Integer)slider.getValue());
                        grid.refresh();
                    }
                }
            });


            heightSpinner.setModel(new SpinnerNumberModel(HEIGHT_INIT, HEIGHT_MIN, HEIGHT_MAX, 1));
            heightSpinner.setEditor(new JSpinner.NumberEditor(heightSpinner));
            heightSpinner.setPreferredSize(new Dimension(70, 30));
            heightSpinner.setMaximumSize(heightSpinner.getPreferredSize());
            heightSpinner.addChangeListener(new GatedChangeListener() {
                @Override public void onChangedState(ChangeEvent e)
                {
                    JSpinner spinner = (JSpinner)e.getSource();
                    try {
                        spinner.commitEdit();
                    } catch (ParseException e1) {
                        e1.printStackTrace();
                    }
                    setWidthOfFrames(((Integer)spinner.getValue()));
                    heightSlider.setValue((Integer)spinner.getValue());
                    grid.refresh();
                }
            });


            confirmButton.addActionListener(new ActionListener() {
                @Override public void actionPerformed(ActionEvent e)
                {
                    JButton confirmButton = (JButton)e.getSource();
                    // TODO
                    System.out.println("Num Cols: "
                    + numCols
                    + "\nWidth: "
                    + widthOfFrames
                    + "\nHeight: "
                    + heightOfFrames);
                }
            });

    //      numColsSelectorLabel.setBorder(BorderFactory.createCompoundBorder(
    //                BorderFactory.createLineBorder(Color.red),
    //                numColsSelectorLabel.getBorder()));


            //TODO make a UI that looks nice and isn't bare-bones functional, but this does work on its own.
            // I don't understand the GridBagLayout.  It keeps having weird bugs with sizing and rows and columns not being static and taking up multiple spaces and ugh.


            p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));
            p.setPreferredSize(new Dimension(300, 480));
            p.setSize(new Dimension(300, 480));

            numColsSelectorLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
            numColsSelectorField.setAlignmentX(Component.CENTER_ALIGNMENT);
            widthSlider.setAlignmentX(Component.CENTER_ALIGNMENT);
            heightSlider.setAlignmentX(Component.CENTER_ALIGNMENT);
            confirmButton.setAlignmentX(Component.CENTER_ALIGNMENT);
            widthLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
            heightLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
            widthSpinner.setAlignmentX(Component.CENTER_ALIGNMENT);
            heightSpinner.setAlignmentX(Component.CENTER_ALIGNMENT);


            p.add(Box.createRigidArea(new Dimension(300, 30)));
            p.add(numColsSelectorLabel);
            p.add(Box.createRigidArea(new Dimension(300, 5)));
            p.add(numColsSelectorField);
            p.add(Box.createRigidArea(new Dimension(300, 25)));
            p.add(widthLabel);
            p.add(Box.createRigidArea(new Dimension(300, 3)));
            p.add(widthSpinner);
            p.add(widthSlider);
            p.add(Box.createRigidArea(new Dimension(300, 25)));
            p.add(heightLabel);
            p.add(Box.createRigidArea(new Dimension(300, 3)));
            p.add(heightSpinner);
            p.add(heightSlider);
            p.add(Box.createRigidArea(new Dimension(300, 45)));
            p.add(confirmButton);


            return p;
        }

        private static void makeKeysWindow(BuildGridGUI b)
        {
            JFrame inputKeysWindow = new JFrame("Input Keys");
            inputKeysWindow.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            inputKeysWindow.setSize(300, 400);
            inputKeysWindow.setResizable(false);
            inputKeysWindow.getContentPane().add(b.keysPanel(inputKeysWindow));
            inputKeysWindow.setVisible(true);
        }

        // enter a bunch of strings; they'll be the data put into the grid.
        // currently just takes count of number of strings and uses that to infer the rows
        private final JComponent keysPanel(JFrame frame)
        {
            JPanel p = new JPanel();

            JTextArea textField = new JTextArea();
            JButton confirmButton = new JButton("Confirm");

            textField.setEditable(true);
            textField.setPreferredSize(new Dimension(280, 380));
            textField.setLineWrap(false);

            confirmButton.addActionListener(new ActionListener()
            {
                @Override public void actionPerformed(ActionEvent e) {
                    if (textField.getText().length() != 0) {
                        BuildGridGUI.this.listOfIDs = Arrays.asList(textField.getText().split("\n"));
                        BuildGridGUI.this.numFrames = textField.getLineCount();

                        SwingUtilities.invokeLater(new Runnable() {
                            @Override public void run() {
                                createMainWindow(BuildGridGUI.this);
                                frame.setVisible(false);
                                frame.dispose();
                            }
                        });
                    }
                }
            });

            p.setLayout(new BoxLayout(p, BoxLayout.Y_AXIS));

            textField.setAlignmentX(Container.CENTER_ALIGNMENT);
            confirmButton.setAlignmentX(Container.CENTER_ALIGNMENT);

            p.add(textField);
            p.add(confirmButton);

            return p;
        }





        void setWidthOfFrames(int x)
        {
            this.widthOfFrames = x;
        }

        void setHeightOfFrames(int y)
        {
            this.heightOfFrames = y;
        }

        void setNumCols(int x)
        {
            this.numCols = x;
        }

        void setNumFrames(int x)
        {
            this.numFrames = x;
        }


        public static void createAndShowGUI()
        {
            try {
                for (UIManager.LookAndFeelInfo lookAndFeel : UIManager.getInstalledLookAndFeels())
                    if ("Nimbus".equals(lookAndFeel.getName()))
                        UIManager.setLookAndFeel(lookAndFeel.getClassName());

            } catch (Exception e) {
                e.printStackTrace();
            }

            BuildGridGUI b = new BuildGridGUI();

            makeKeysWindow(b);

        }




        private static void createMainWindow(BuildGridGUI b) {
            JFrame mainFrame = new JFrame("Grid Builder");
            //mainFrame.getContentPane().setLayout(new BoxLayout(mainFrame.getContentPane(), BoxLayout.PAGE_AXIS));
            mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            mainFrame.setSize(940, 480);
            mainFrame.getContentPane().add(b.makeUI());
            mainFrame.setResizable(false);
            mainFrame.setVisible(true);
        }


        public static void main(String... args)
        {
            SwingUtilities.invokeLater(new Runnable() {
                @Override public void run() {
                    createAndShowGUI();
                }
            });
        }


        @SuppressWarnings("serial")
        class Grid extends JComponent
        {
            static final int CANVAS_WIDTH = 640;
            static final int CANVAS_HEIGHT = 480;

            private final double conversionRatio = 4.0/9.0; // 1080p scaled down to 480p preview

            private int squareHeight, squareWidth, numColumns, numRows;


            public Grid()
            {
                setOpaque(true);
                setSize(CANVAS_WIDTH, CANVAS_HEIGHT); // trying to get the size to work properly.
                setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
            }

            @Override
            public Dimension getPreferredSize()
            {
                return new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT);
            }

            @Override
            public void paintComponent(Graphics g)
            {

                super.paintComponent(g);

                updateVars();

                int k;

                for (k = 0; k < numColumns; k++)
                {
                    // @param: (x1, y1), (x2, y2)
                    g.drawLine(k * squareWidth, 0, k * squareWidth, CANVAS_HEIGHT);
                }

                for (k = 0; k < numRows; k++)
                {
                    g.drawLine(0, k * squareHeight, CANVAS_WIDTH, k * squareHeight);
                }
            }

            public void refresh()
            {
                // Attempting to set the repaint area to only the grid region
                // because CTRL+F is free and parameters are not
                repaint(0, 0, CANVAS_WIDTH, CANVAS_HEIGHT);
            }

            public void updateVars()
            {
                this.squareWidth = (int)(
                        (double)BuildGridGUI.this.widthOfFrames
                        *
                        conversionRatio);

                this.squareHeight = (int)(
                        (double)BuildGridGUI.this.heightOfFrames
                        *
                        conversionRatio);

                this.numColumns = BuildGridGUI.this.numCols;

                this.numRows = (int)(
                        (
                                (double)BuildGridGUI.this.numFrames
                                /
                                numColumns
                        )
                        + 0.5);
            }

        }

    }



    abstract class GatedChangeListener implements ChangeListener
    {
        private static boolean enabled = true;

        public static void setEnabled(boolean enabled)
        {
            GatedChangeListener.enabled = enabled;
        }

        protected abstract void onChangedState(ChangeEvent e);

        @Override
        public final void stateChanged(ChangeEvent e)
        {
            if(enabled)
                onChangedState(e);
        }
    }