from PyQt5 import QtWidgets as QtW
from PyQt5 import QtCore as QtC
import threading as th
import numpy as np
import sys


class MainWindow(QtW.QMainWindow):
    def __init__(self):
        self.monitor = th.Condition()
        super().__init__()
        self.threads = []
        self.elements_num = 19629687
        self.array = np.random.random_integers(-20000000, 20000000, self.elements_num)
        self.min_element = self.array[0]
        self.number_of_threads_to_create_label = QtW.QLabel(self)
        self.number_of_threads_to_create_box = QtW.QComboBox(self)
        self.create_threads_button = QtW.QPushButton('Create threads', self)
        self.threads_table = QtW.QTableWidget(self)



        self.progress_bar = QtW.QProgressBar(self)
        self.use_sync = QtW.QCheckBox(self)
        self.use_sync.setGeometry(10, 160, 100, 14)
        self.use_sync.setText("Monitor")
        self.use_sync_wait = QtW.QCheckBox(self)
        self.use_sync_wait.setGeometry(10, 170, 100, 14)
        self.use_sync_wait.setText("Timer")
        self.widget_settings()
        self.show()

        self.timer = QtC.QTimer(self)
        self.timer.setInterval(250)
        self.timer.timeout.connect(self.update_table)
        self.timer.start()




    def widget_settings(self):
        self.setFixedSize(700, 190)
        self.setGeometry(150, 70, 700, 190)
        self.setWindowTitle('Lab10')

        self.number_of_threads_to_create_label.setText("<h2 align='right'>Number:</h2>")
        self.number_of_threads_to_create_label.setGeometry(5, 10, 94, 30)

        self.number_of_threads_to_create_box.setGeometry(100, 10, 32, 30)
        self.number_of_threads_to_create_box.addItems(['1', '2', '4', '8'])

        self.create_threads_button.setGeometry(4, 40, 130, 30)
        self.create_threads_button.clicked.connect(self.create_threads)

        self.progress_bar.setGeometry(150, 152, 540, 30)
        self.progress_bar.setMinimum(0)
        self.progress_bar.setMaximum(self.elements_num)
        self.progress_bar.setAlignment(QtC.Qt.AlignCenter)

        self.threads_table.setColumnCount(3)
        self.threads_table.setSelectionBehavior(QtW.QAbstractItemView.SelectRows)
        self.threads_table.setSelectionMode(QtW.QAbstractItemView.SingleSelection)
        self.threads_table.setHorizontalHeaderLabels(['Name', 'Min Element', 'Progress'])
        self.threads_table.setGeometry(150, 10, 540, 134)
        self.threads_table.setFixedSize(540, 134)
        self.threads_table.horizontalHeader().setStretchLastSection(True)
        self.threads_table.verticalHeader().setDefaultSectionSize(20)
        self.threads_table.setColumnWidth(0, 50)
        for i in range(8):
            self.threads_table.setRowHeight(i, 20)

    def create_threads(self):
        self.create_threads_button.setDisabled(True)
        self.threads.clear()
        t_num = 2 ** self.number_of_threads_to_create_box.currentIndex()

        func = self.find_minimal

        if self.use_sync.isChecked():
            func = self.find_minimal_sync

        for i in range(t_num):
            left = len(self.array)//t_num*i
            if i == t_num -1:
                right = len(self.array)
            else:
                right = len(self.array)//t_num*(i+1)

            self.threads.append([th.Thread(target=func,
                                           args=(left, right, i),
                                           name="Thread "+str(i))])
            self.threads[-1].append([0, right-left])
            self.threads[-1].append(self.array[left])
            self.threads[-1][0].start()

        if self.use_sync_wait.isChecked():
            self.progress_bar.setValue(0)
            self.progress_bar.setEnabled(True)
            wait = th.Thread(target=self.update_progress, daemon=True)
            wait.start()
        else:
            self.progress_bar.setDisabled(True)

    def update_progress(self):
        if len(self.threads) and self.progress_bar.value() < self.elements_num:
            self.progress_bar.setValue(sum([x[1][0] for x in self.threads]))
            timer = th.Timer(0.5, self.update_progress)
            timer.setDaemon(True)
            timer.start()


    def update_table(self):
        try:
            selected_thread = 0
            if self.threads and self.threads_table.selectedIndexes():
                selected_thread = self.threads[self.threads_table.selectionModel().selectedRows()[0].row()]

            done = 1
            for i in self.threads:
                if len(i) == 3:
                    done = 0
            if done:
                self.create_threads_button.setDisabled(False)

            self.threads_table.setRowCount(0)
            for j, i in enumerate(self.threads):
                self.threads_table.insertRow(j)
                row = [QtW.QTableWidgetItem(x) for x in [
                    i[0].getName(),
                    str(i[2]),
                    str(i[1][0]) + '/' + str(i[1][1]),
                    ]
                ]

                for k in row:
                    k.setFlags(QtC.Qt.ItemIsEnabled | QtC.Qt.ItemIsSelectable)
                self.threads_table.setItem(j, 0, row[0])
                self.threads_table.setItem(j, 1, row[1])
                self.threads_table.setItem(j, 2, row[2])

            if selected_thread in self.threads:
                self.threads_table.selectRow(self.threads.index(selected_thread))

        except:
            pass

    def find_minimal(self, left_border, right_border, num):
        self.threads[num][2] = self.array[left_border]
        for i in range(left_border, right_border):
            self.threads[num][1][0] += 1
            if self.array[i] < self.threads[num][2]:
                self.threads[num][2] = self.array[i]
        self.threads[num].append("Done")

    def find_minimal_sync(self, left_border, right_border, num):
        self.threads[num][2] = self.array[left_border]
        for i in range(left_border, right_border):
            self.threads[num][1][0] += 1

            if self.array[i] < self.threads[num][2]:
                self.threads[num][2] = self.array[i]
        self.threads[num].append("Done")


if __name__ == '__main__':
    app = QtW.QApplication(sys.argv)
    window = MainWindow()
    sys.exit(app.exec_())