import tkinter as tk
import numpy as np
from scipy.optimize import linprog


class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Zagadnienie pośrednika")

        tk.Label(self, text="Podaż (rozdelone przecinkami):").grid(row=0, column=0)
        self.supply_entry = tk.Entry(self)
        self.supply_entry.grid(row=0, column=1)

        tk.Label(self, text="Popyt (rozdelone przecinkami):").grid(row=1, column=0)
        self.demand_entry = tk.Entry(self)
        self.demand_entry.grid(row=1, column=1)

        tk.Label(self, text="Ceny zakupu (rozdelone przecinkami):").grid(row=2, column=0)
        self.purchase_prices_entry = tk.Entry(self)
        self.purchase_prices_entry.grid(row=2, column=1)

        tk.Label(self, text="Ceny sprzedaży (rozdelone przecinkami):").grid(row=3, column=0)
        self.sale_prices_entry = tk.Entry(self)
        self.sale_prices_entry.grid(row=3, column=1)

        tk.Label(self, text="Koszty transportu (rozdelone przecinkami):").grid(row=4, column=0)
        self.transport_costs_entry = tk.Entry(self)
        self.transport_costs_entry.grid(row=4, column=1)

        self.calculate_button = tk.Button(self, text="Oblicz", command=self.calculate)
        self.calculate_button.grid(row=5, column=1, pady=10)

    def display_results(self, results_text):
        results_window = tk.Toplevel(self)
        results_window.title("Wyniki")
        results_label = tk.Label(results_window, text=results_text, justify=tk.LEFT)
        results_label.pack(padx=20, pady=20)

    def calculate(self):
        supply = np.array(list(map(float, self.supply_entry.get().split(','))))
        demand = np.array(list(map(float, self.demand_entry.get().split(','))))
        purchase_prices = np.array(list(map(float, self.purchase_prices_entry.get().split(','))))
        sale_prices = np.array(list(map(float, self.sale_prices_entry.get().split(','))))
        transport_costs = np.array(list(map(float, self.transport_costs_entry.get().split(','))))

        num_suppliers = len(supply)
        num_consumers = len(demand)

        transport_costs = transport_costs.reshape(num_suppliers, num_consumers)
        profits = sale_prices.reshape(1, -1) - purchase_prices.reshape(-1, 1) - transport_costs

        costs = profits.flatten()

        supply_constraints = np.zeros((num_suppliers, num_suppliers * num_consumers))
        for i in range(num_suppliers):
            supply_constraints[i, i::num_suppliers] = 1

        demand_constraints = np.zeros((num_consumers, num_suppliers * num_consumers))
        for i in range(num_consumers):
            demand_constraints[i, i * num_suppliers:(i + 1) * num_suppliers] = 1
        A_eq = np.vstack([supply_constraints, demand_constraints])
        b_eq = np.concatenate([supply, demand])

        try:
            res = linprog(-costs, A_eq=A_eq, b_eq=b_eq, method='highs')
        except Exception as e:
            self.display_results(f"Błąd podczas optymalizacji: {e}")
            print(e)
            return

        if res.success:
            optimal_transfers = np.round(res.x.reshape(num_suppliers, num_consumers))
            total_cost = np.sum(optimal_transfers * transport_costs)
            total_revenue = np.sum(optimal_transfers * (sale_prices - purchase_prices.reshape(-1, 1)))
            total_profit = np.sum(optimal_transfers * profits)

            results_text = (
                "Tabela zysków jednostkowych:\n" + str(profits) +
                "\n\nTabela optymalnych przewozów:\n" + str(optimal_transfers) +
                f"\n\nKoszt całkowity: {total_cost:.2f}" +
                f"\nPrzychód całkowity: {total_revenue:.2f}" +
                f"\nZysk pośrednika: {total_profit:.2f}"
            )
            self.display_results(results_text)
        else:
            self.display_results(f"Błąd podczas optymalizacji: {res.message}")


if __name__ == "__main__":
    app = App()
    app.mainloop()