package ProjectElectricLocomotive;

import javax.swing.*;
import java.awt.*;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.border.Border;
import java.io.IOException;

public class FormLocomotiveConfig{

    public DrawingLocomotive _loco;
    private JPanel MainPanel;
    private JPanel groupBoxObjectParameters;
    private JPanel groupBoxColors;
    private JSpinner numericUpDownSpeed;
    private JSpinner numericUpDownWeight;
    private JLabel labelSpeed;
    private JLabel labelWeight;
    private JCheckBox checkBoxHorns;
    private JCheckBox checkBoxSeifBatteries;
    public JLabel lableSimpleObject;
    private JLabel labelModifiedObject;
    public JButton buttonOk;
    public JButton buttonClose;
    private JLabel labelColor;
    private JLabel labelDopColor;
    public JComponent pictureBoxObject;
    private JPanel redPanel;
    private JPanel orangePanel;
    private JPanel yellowPanel;
    private JPanel ligthGreenPanel;
    private JPanel melissePanel;
    private JPanel ligthBluePanel;
    private JPanel bluePanel;
    private JPanel violetPanel;
    private JPanel panelBodyColor;
    private JPanel panelAdditionalColor;
    private JLabel labelBlackWheels;
    private JLabel labelCountWheels;
    private JSpinner numericUpDownWheels;
    private JLabel labelEmptyWheels;
    private JLabel labelRainbowWheels;
    public Canvas canvas;

    public JPanel getPictureBoxObject(){
        return MainPanel;
    }

    private class Canvas extends JComponent{
        public Canvas(){
        }
        public void paintComponent (Graphics g){
            if (_loco == null){
                return;
            }
            super.paintComponents (g) ;
            Graphics2D g2d = (Graphics2D)g;
            _loco.DrawTransport(g2d);
            super.repaint();
        }
    }

    // класс для перетаскивания информации из labe'лов
    private class LabelTransferHandler extends TransferHandler {
        @Override
        public int getSourceActions(JComponent c) {
            return TransferHandler.COPY;
        }

        @Override
        protected Transferable createTransferable(JComponent c) {
            return new StringSelection(((JLabel)c).getText());
        }
    }

    //для перетаскивания цветов
    private class ColorTransferable implements Transferable {
        private Color color;
        private static final DataFlavor colorDataFlavor = new DataFlavor(Color.class, "Color");

        public ColorTransferable(Color color) {
            this.color = color;
        }

        @Override
        public DataFlavor[] getTransferDataFlavors() {
            return new DataFlavor[]{colorDataFlavor};
        }

        @Override
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            return colorDataFlavor.equals(flavor);
        }

        @Override
        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
            if (isDataFlavorSupported(flavor)) {
                return color;
            } else {
                throw new UnsupportedFlavorException(flavor);
            }
        }
    }

    //для перетаскивания цвета
    private class PanelTransferHandler extends TransferHandler {
        @Override
        public int getSourceActions(JComponent c) {
            return TransferHandler.COPY;
        }

        @Override
        protected Transferable createTransferable(JComponent c) {
            return new ColorTransferable(((JPanel)c).getBackground());
        }
    }

    //для обработки "схватывания" label'ов
    private class LabelMouseAdapter extends MouseAdapter {
        @Override
        public void mousePressed(MouseEvent e) {
            ((JLabel)e.getComponent()).getTransferHandler().exportAsDrag(((JLabel)e.getComponent()), e, TransferHandler.COPY);
        }
    }

    //для обработки "схватывания" panel'ей
    private class PanelMouseAdapter extends MouseAdapter{
        @Override
        public void mousePressed(MouseEvent e) {
            ((JPanel)e.getComponent()).getTransferHandler().exportAsDrag(((JPanel)e.getComponent()), e, TransferHandler.COPY);
        }
    }

    public FormLocomotiveConfig()
    {
        Border br = BorderFactory.createLineBorder(Color.BLACK);

        SpinnerModel numSpeed = new SpinnerNumberModel(100, 100, 1000, 1);
        numericUpDownSpeed = new JSpinner(numSpeed);

        SpinnerModel numWeight = new SpinnerNumberModel(100, 100, 1000, 1);
        numericUpDownWeight = new JSpinner(numWeight);

        lableSimpleObject.setTransferHandler(new LabelTransferHandler());
        lableSimpleObject.addMouseListener(new LabelMouseAdapter());
        lableSimpleObject.setBorder(br);

        labelModifiedObject.setTransferHandler(new LabelTransferHandler());
        labelModifiedObject.addMouseListener(new LabelMouseAdapter());
        labelModifiedObject.setBorder(br);

        labelBlackWheels.setTransferHandler(new TransferHandler(){
            @Override
            public int getSourceActions(JComponent c) {
                return TransferHandler.COPY;
            }

            @Override
            protected Transferable createTransferable(JComponent c) {
                return new WheelsTransferable(new DrawingWheel());
            }
        });
        labelBlackWheels.addMouseListener(new LabelMouseAdapter());
        labelBlackWheels.setBorder(br);

        labelEmptyWheels.setTransferHandler(new TransferHandler(){
            @Override
            public int getSourceActions(JComponent c) {
                return TransferHandler.COPY;
            }

            @Override
            protected Transferable createTransferable(JComponent c) {
                return new WheelsTransferable(new DrawingEmptyWheels());
            }
        });
        labelEmptyWheels.addMouseListener(new LabelMouseAdapter());
        labelEmptyWheels.setBorder(br);

        labelRainbowWheels.setTransferHandler( new TransferHandler(){
            @Override
            public int getSourceActions(JComponent c) {
                return TransferHandler.COPY;
            }

            @Override
            protected Transferable createTransferable(JComponent c) {
                return new WheelsTransferable(new DrawingWheelsBlueCrom());
            }
        });
        labelRainbowWheels.addMouseListener(new LabelMouseAdapter());
        labelRainbowWheels.setBorder(br);

        redPanel.setTransferHandler(new PanelTransferHandler());
        redPanel.addMouseListener(new PanelMouseAdapter());

        orangePanel.setTransferHandler(new PanelTransferHandler());
        orangePanel.addMouseListener(new PanelMouseAdapter());

        yellowPanel.setTransferHandler(new PanelTransferHandler());
        yellowPanel.addMouseListener(new PanelMouseAdapter());

        ligthGreenPanel.setTransferHandler(new PanelTransferHandler());
        ligthGreenPanel.addMouseListener(new PanelMouseAdapter());

        melissePanel.setTransferHandler(new PanelTransferHandler());
        melissePanel.addMouseListener(new PanelMouseAdapter());

        ligthBluePanel.setTransferHandler(new PanelTransferHandler());
        ligthBluePanel.addMouseListener(new PanelMouseAdapter());

        bluePanel.setTransferHandler(new PanelTransferHandler());
        bluePanel.addMouseListener(new PanelMouseAdapter());

        violetPanel.setTransferHandler(new PanelTransferHandler());
        violetPanel.addMouseListener(new PanelMouseAdapter());

        labelColor.setBorder(br);
        labelColor.setTransferHandler(
                new TransferHandler(){
                    @Override
                    public boolean canImport(TransferHandler.TransferSupport support)
                    {
                        try{
                            Color color = (Color) support.getTransferable().getTransferData(ColorTransferable.colorDataFlavor);
                            if(_loco == null) return false;
                            _loco.EntityLocomotive.SetBodyColor(color);

                            panelBodyColor.setBackground(color);

                            Border border = BorderFactory.createLineBorder(color);

                            labelColor.setBorder(border);
                            return true;
                        }
                        catch(UnsupportedFlavorException | IOException e){
                        }
                        return false;
                    }
                }
        );

        labelDopColor.setBorder(br);
        labelDopColor.setTransferHandler(
                new TransferHandler(){
                    @Override
                    public boolean canImport(TransferHandler.TransferSupport support)
                    {
                        try{
                            Color color = (Color) support.getTransferable().getTransferData(ColorTransferable.colorDataFlavor);
                            panelAdditionalColor.setBackground(color);
                            Border border = BorderFactory.createLineBorder(color);
                            labelDopColor.setBorder(border);
                            if(_loco == null) return false;
                            if(!(_loco instanceof DrawingElectricLocomotive))
                                return false;
                            ((EntityElectricLocomotive)_loco.EntityLocomotive).SetAdditionalColor(color);
                            return true;
                        }
                        catch(UnsupportedFlavorException | IOException e){
                        }
                        return false;
                    }

                }
        );

        pictureBoxObject.setTransferHandler(
                new TransferHandler(){
                    @Override
                    public boolean canImport(TransferHandler.TransferSupport support) {
                        return support.isDataFlavorSupported(DataFlavor.stringFlavor) || support.isDataFlavorSupported(WheelsTransferable.wheelsDrawingDataFlavor);
                    }

                    @Override
                    public boolean importData(TransferHandler.TransferSupport support) {
                        if (canImport(support)) {
                            try {
                                String data = (String) support.getTransferable().getTransferData(DataFlavor.stringFlavor);
                                switch (data) {
                                    case "Простой":
                                        _loco = new DrawingLocomotive(
                                                (int)numericUpDownSpeed.getValue(),
                                                (int)numericUpDownWeight.getValue(),
                                                Color.WHITE,
                                                pictureBoxObject.getWidth(),
                                                pictureBoxObject.getHeight()
                                        );
                                        break;
                                    case "Сложный":
                                        _loco = new DrawingElectricLocomotive(
                                                (int)numericUpDownSpeed.getValue(),
                                                (int)numericUpDownWeight.getValue(),
                                                Color.WHITE,
                                                Color.BLACK,
                                                checkBoxHorns.isSelected(),
                                                checkBoxSeifBatteries.isSelected(),
                                                pictureBoxObject.getWidth(),
                                                pictureBoxObject.getHeight()
                                        );
                                        break;
                                }

                            } catch (UnsupportedFlavorException | IOException e) {
                            }
                            try{
                                int wheelsCount = (int)numericUpDownWheels.getValue();
                                IDrawingWheels drawingWheels = (IDrawingWheels) support.getTransferable().getTransferData(WheelsTransferable.wheelsDrawingDataFlavor);
                                _loco._drawingWheels = drawingWheels;
                                _loco.SetWheelsCount(wheelsCount);
                            }catch(UnsupportedFlavorException | IOException e){
                            }
                            pictureBoxObject.repaint();
                            return true;
                        }
                        return false;
                    }
                }
        );
    }

    private class WheelsTransferable implements Transferable {
        private IDrawingWheels drawingWheels;
        private static final DataFlavor wheelsDrawingDataFlavor = new DataFlavor(IDrawingWheels.class, "Wheels Drawing");

        public WheelsTransferable(IDrawingWheels drawingWheels) {
            this.drawingWheels = drawingWheels;
        }

        @Override
        public DataFlavor[] getTransferDataFlavors() {
            return new DataFlavor[]{wheelsDrawingDataFlavor};
        }

        @Override
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            return flavor.equals(wheelsDrawingDataFlavor);
        }

        @Override
        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {
            if (isDataFlavorSupported(flavor)) {
                return drawingWheels;
            } else {
                throw new UnsupportedFlavorException(flavor);
            }
        }
    }

    private void createUIComponents(){
        pictureBoxObject = new Canvas();
        pictureBoxObject.setBounds(new Rectangle(300, 300));

        SpinnerModel numSpeed = new SpinnerNumberModel(100, 100, 1000, 1);
        numericUpDownSpeed = new JSpinner(numSpeed);

        SpinnerModel numWeight = new SpinnerNumberModel(100, 100, 1000, 1);
        numericUpDownWeight = new JSpinner(numWeight);

        SpinnerModel numWheels = new SpinnerNumberModel(2,2, 4, 1);
        numericUpDownWheels = new JSpinner(numWheels);
    }

}