package com.company;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Collections;

public class Sorting extends JPanel {
    //Количество элементов
    private static final int NUM_ITEMS = 50;

    //Панель для отрисовки массивов
    private JPanel panelBooble , panelInsert;
    //Кнопка старта и сброса
    private JButton startButton , resetButton;
    //Объекты внутреннего цикла
    private Timer timerBooble, timerInsert;
    //Объекты внешнего цикла
    private Thread thBooble , thInsert;
    //Массивы для сортировки
    private Integer[] arrayBooble, arrayInsert;
    //Переменные счетчики для сортировки вставками
    private int indexInsertI ,indexInserJ , temp;
    //Переменные счечтики для сортировки пузырьком
    private int indexBoobleI , indexBoobleJ;
    //Флаги
    private boolean bBooble , stopFlagBooble , bInser , stopFlagInsert;

    //Конструктор
    public Sorting(){
        //Установка Layout
        setLayout(new BorderLayout());

        //Инициализация массивов
        arrayBooble = initArray();
        arrayInsert = Arrays.copyOf(arrayBooble , NUM_ITEMS);

        //Инициализация Timer "внутреннего цикла"
        timerBooble = new Timer(25, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //Проверка что внутрений цикл дошел до конца
                if (indexBoobleJ >= indexBoobleI-1) {
                    bBooble = true;
                    synchronized (thBooble){
                        //Разрешаем внешнему циклу продолжить работу
                        thBooble.notify();
                    }
                    //Останавливаем таймер
                    ((Timer) e.getSource()).stop();
                }
                //Проверяем рядом стоящие элементы и меняем их местами если условие выполняется
                if (arrayBooble[indexBoobleJ] > arrayBooble[indexBoobleJ + 1]) {
                    int booble = arrayBooble[indexBoobleJ];
                    arrayBooble[indexBoobleJ] = arrayBooble[indexBoobleJ + 1];
                    arrayBooble[indexBoobleJ + 1] = booble;
                    panelBooble.repaint();
                }
                //Увеличиваем счетчик внутреннего цикла на 1
                indexBoobleJ++;
            }
        });

        //Инициализация Timer "внутреннего цикла"
        timerInsert = new Timer(25, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //Проверка что внутрений цикл дошел до конца
                if (indexInserJ < 0 || arrayInsert[indexInserJ] < temp) {
                    bInser = true;
                    synchronized (thInsert){
                        //Разрешаем внешнему циклу продолжить работу
                        thInsert.notify();
                    }
                    //Останавливаем таймер
                    ((Timer) e.getSource()).stop();
                }else {
                    //Перезаписываем элемент
                    arrayInsert[indexInserJ + 1] = arrayInsert[indexInserJ];
                    panelInsert.repaint();
                    indexInserJ--;
                }
            }
        });

        //Инициализация кнопки старта сортировки
        startButton = new JButton("Start");
        startButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //Обнуляем флаги
                stopFlagInsert = false;
                stopFlagBooble = false;
                //Инициализируем счетчик для пузырьковой сортировки
                indexBoobleI = NUM_ITEMS - 1;
                //Инициализируем счетчик для сортировки вставками
                indexInsertI = 1;
                //Инициализируем поток внешнего цикла
                thBooble = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        while(!stopFlagBooble) {
                            try {
                                //Завершаем поток после того как массив отсортирован
                                if (indexBoobleI <= 1) {
                                    stopFlagBooble = true;
                                }
                                //Переменная счетчик внутреннего цикла
                                indexBoobleJ = 0;
                                bBooble = false;
                                //Запускаем работу внутреннего цикла
                                timerBooble.start();
                                synchronized (thBooble) {
                                    while (!bBooble) {
                                        //Ожидаем пока внутренний цикл завершит работу
                                        thBooble.wait();
                                    }
                                }
                                indexBoobleI--;
                            } catch (Exception ex) {
                                ex.getStackTrace();
                            }
                        }
                    }
                });
                //Инициализируем поток внешнего цикла
                thInsert = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        while(!stopFlagInsert) {
                            try {
                                //Завершаем поток после того как массив отсортирован
                                if (indexInsertI >= NUM_ITEMS) {
                                    stopFlagInsert = true;
                                }
                                temp = arrayInsert[indexInsertI];
                                indexInserJ = indexInsertI - 1;
                                bInser = false;
                                //Запускаем работу внутреннего цикла
                                timerInsert.start();
                                synchronized (thInsert) {
                                    while (!bInser) {
                                        //Ожидаем пока внутренний цикл завершит работу
                                        thInsert.wait();
                                    }
                                }
                                arrayInsert[indexInserJ + 1] = temp;
                                panelInsert.repaint();
                                indexInsertI++;
                            } catch (Exception ex) {
                                ex.getStackTrace();
                            }
                        }
                    }
                });
                //Запускаем потоки
                thBooble.start();
                thInsert.start();
            }
        });
        //Сбросить
        resetButton = new JButton("Reset");
        resetButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                stopFlagBooble = true;
                stopFlagInsert = true;
                arrayBooble = initArray();
                arrayInsert = Arrays.copyOf(arrayBooble , NUM_ITEMS);
                panelInsert.repaint();
                panelBooble.repaint();
            }
        });

        //Панель для отрисовки массива алгоритма пузырьковой сортировки
        panelBooble = new JPanel(){
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                int heightItem = panelBooble.getHeight()/NUM_ITEMS;
                int widthItem = (panelBooble.getWidth()/NUM_ITEMS);
                for(int i = 0; i < NUM_ITEMS; i++){
                    int height = arrayBooble[i]*heightItem;
                    int x = i * widthItem;
                    g.drawRect(x , panelBooble.getHeight()-height , widthItem , height);
                }
            }
        };

        //Панель для отрисовки массива алгоритма сортировки вставками
        panelInsert = new JPanel(){
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                int heightItem = panelInsert.getHeight()/NUM_ITEMS;
                int widthItem = (panelInsert.getWidth()/NUM_ITEMS);
                for(int i = 0; i < NUM_ITEMS; i++){
                    int height = arrayInsert[i]*heightItem;
                    int x = i * widthItem;
                    g.drawRect(x , panelInsert.getHeight()-height , widthItem , height);
                }
            }
        };

        JPanel panelNorth = new JPanel();
        panelNorth.setLayout(new GridLayout(1,2));
        panelNorth.add(startButton);
        panelNorth.add(resetButton);
        add(panelNorth , BorderLayout.NORTH);
        JPanel panelCenter = new JPanel();
        panelCenter.setLayout(new GridLayout(2,1));
        panelCenter.add(panelBooble);
        panelCenter.add(panelInsert);
        add(panelCenter);
    }

    //Метод для создание рандомного массива
    public Integer[] initArray(){
        Integer[] nums = new Integer[NUM_ITEMS];
        for (int i = 1; i <= nums.length; i++) {
            nums[i - 1] = i;
        }
        Collections.shuffle(Arrays.asList(nums));
        return nums;
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Sorting");
        frame.add(new Sorting());
        frame.setPreferredSize(new Dimension(800,600));
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}