from PyQt5.QtWidgets import QWidget, QApplication, QColorDialog, QPushButton, QVBoxLayout, QGridLayout, QLabel, \
    QLineEdit, QSizePolicy
import sys


class Window(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)

        self.red = 0
        self.green = 0
        self.blue = 0
        self.cyan = 0
        self.magenta = 0
        self.yellow = 0
        self.black = 0

        self.red_channel_input = QLineEdit(self)
        self.green_channel_input = QLineEdit(self)
        self.blue_channel_input = QLineEdit(self)
        self.cyan_channel_input = QLineEdit(self)
        self.magenta_channel_input = QLineEdit(self)
        self.yellow_channel_input = QLineEdit(self)
        self.black_channel_input = QLineEdit(self)

        self.red_channel_input.setReadOnly(True)
        self.green_channel_input.setReadOnly(True)
        self.blue_channel_input.setReadOnly(True)
        self.cyan_channel_input.setReadOnly(True)
        self.magenta_channel_input.setReadOnly(True)
        self.yellow_channel_input.setReadOnly(True)
        self.black_channel_input.setReadOnly(True)

        self.red_channel_input.setStyleSheet("background-color: darkGray")
        self.green_channel_input.setStyleSheet("background-color: darkGray")
        self.blue_channel_input.setStyleSheet("background-color: darkGray")
        self.cyan_channel_input.setStyleSheet("background-color: darkGray")
        self.magenta_channel_input.setStyleSheet("background-color: darkGray")
        self.yellow_channel_input.setStyleSheet("background-color: darkGray")
        self.black_channel_input.setStyleSheet("background-color: darkGray")

        self.color_button = QPushButton()
        self.color_button.setSizePolicy(
            QSizePolicy.Preferred,
            QSizePolicy.Expanding)

        self.interface()

    def interface(self):
        pick_color = QPushButton("Pick a color", self)
        # draw_cube = QPushButton("Draw a 3D cube", self)
        convert_to_rgb = QPushButton("Convert from CMYK to RGB", self)
        convert_to_cmyk = QPushButton("Convert from RGB to CMYK", self)

        pick_color.clicked.connect(self.color_picker)
        convert_to_rgb.clicked.connect(self.cmyk_to_rgb)
        convert_to_cmyk.clicked.connect(self.rgb_to_cmyk)

        box_layout = QVBoxLayout()

        box_layout.addWidget(pick_color)
        # box_layout.addWidget(draw_cube)
        box_layout.addWidget(convert_to_rgb)
        box_layout.addWidget(convert_to_cmyk)

        grid_layout = QGridLayout()
        grid_layout.addLayout(box_layout, 1, 1)

        input_grid_layout = QGridLayout()
        grid_layout.addLayout(input_grid_layout, 0, 1)

        red_label = QLabel("R:", self)
        green_label = QLabel("G:", self)
        blue_label = QLabel("B:", self)
        cyan_label = QLabel("C:", self)
        magenta_label = QLabel("M:", self)
        yellow_label = QLabel("Y:", self)
        black_label = QLabel("K:", self)

        red_box = QVBoxLayout()
        red_box.addWidget(red_label)
        red_box.addWidget(self.red_channel_input)

        green_box = QVBoxLayout()
        green_box.addWidget(green_label)
        green_box.addWidget(self.green_channel_input)

        blue_box = QVBoxLayout()
        blue_box.addWidget(blue_label)
        blue_box.addWidget(self.blue_channel_input)

        cyan_box = QVBoxLayout()
        cyan_box.addWidget(cyan_label)
        cyan_box.addWidget(self.cyan_channel_input)

        magenta_box = QVBoxLayout()
        magenta_box.addWidget(magenta_label)
        magenta_box.addWidget(self.magenta_channel_input)

        yellow_box = QVBoxLayout()
        yellow_box.addWidget(yellow_label)
        yellow_box.addWidget(self.yellow_channel_input)

        black_box = QVBoxLayout()
        black_box.addWidget(black_label)
        black_box.addWidget(self.black_channel_input)

        input_grid_layout.addLayout(red_box, 0, 1)
        input_grid_layout.addLayout(green_box, 0, 2)
        input_grid_layout.addLayout(blue_box, 0, 3)
        input_grid_layout.addLayout(cyan_box, 1, 1)
        input_grid_layout.addLayout(magenta_box, 1, 2)
        input_grid_layout.addLayout(yellow_box, 1, 3)
        input_grid_layout.addLayout(black_box, 1, 4)
        input_grid_layout.addWidget(self.color_button, 0, 0)

        self.setLayout(grid_layout)

        self.setGeometry(760, 440, 200, 200)
        self.setWindowTitle("Zadanie3")

    @staticmethod
    def get_rgb_string(red, green, blue):
        return "rgb({}, {}, {})".format(red, green, blue)

    def color_picker(self):
        color = QColorDialog.getColor()

        self.red = color.red()
        self.green = color.green()
        self.blue = color.blue()
        self.cyan = self.scale_down_color_channel(color.cyan())
        self.magenta = self.scale_down_color_channel(color.magenta())
        self.yellow = self.scale_down_color_channel(color.yellow())
        self.black = self.scale_down_color_channel(color.black())

        self.color_button.setStyleSheet("background-color: {}".format(self.get_rgb_string(self.red, self.green, self.blue)))

        self.red_channel_input.clear()
        self.green_channel_input.clear()
        self.blue_channel_input.clear()

        self.cyan_channel_input.clear()
        self.magenta_channel_input.clear()
        self.yellow_channel_input.clear()
        self.black_channel_input.clear()

    def rgb_to_cmyk(self):
        red = self.scale_down_color_channel(self.red)
        green = self.scale_down_color_channel(self.green)
        blue = self.scale_down_color_channel(self.blue)

        black_channel = min(1 - red, 1 - green, 1 - blue)

        if black_channel == 1:
            cyan_channel = 0
            magenta_channel = 0
            yellow_channel = 0
        else:
            cyan_channel = (1 - red - black_channel) / (1 - black_channel)
            magenta_channel = (1 - green - black_channel) / (1 - black_channel)
            yellow_channel = (1 - blue - black_channel) / (1 - black_channel)

        self.cyan = cyan_channel
        self.magenta = magenta_channel
        self.yellow = yellow_channel
        self.black = black_channel

        self.cyan_channel_input.setText(str(round(self.cyan, 2)))
        self.magenta_channel_input.setText(str(round(self.magenta, 2)))
        self.yellow_channel_input.setText(str(round(self.yellow, 2)))
        self.black_channel_input.setText(str(round(self.black, 2)))

    def cmyk_to_rgb(self):
        self.red = self.scale_up_color_channel(1 - min(1, (self.cyan * (1 - self.black)) + self.black))
        self.green = self.scale_up_color_channel(1 - min(1, (self.magenta * (1 - self.black)) + self.black))
        self.blue = self.scale_up_color_channel(1 - min(1, (self.yellow * (1 - self.black)) + self.black))

        self.red_channel_input.setText(str(round(self.red, 2)))
        self.green_channel_input.setText(str(round(self.green, 2)))
        self.blue_channel_input.setText(str(round(self.blue, 2)))

    @staticmethod
    def scale_down_color_channel(color_channel):
        return color_channel / 255

    @staticmethod
    def scale_up_color_channel(color_channel):
        return color_channel * 255


def main():
    app = QApplication(sys.argv)
    window = Window()
    window.show()

    sys.exit(app.exec_())


if __name__ == "__main__":
    main()