Checkpoint 01.04

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

        total_supply = np.sum(supply)
        total_demand = np.sum(demand)

        if total_supply < total_demand:
            artificial_supply = np.zeros((1, num_consumers))
            transport_costs = np.vstack([transport_costs, artificial_supply])
            supply = np.append(supply, total_demand - total_supply)
            num_suppliers += 1
        elif total_demand < total_supply:
            artificial_demand = np.zeros((num_suppliers, 1))
            transport_costs = np.hstack([transport_costs, artificial_demand])
            demand = np.append(demand, total_supply - total_demand)
            num_consumers += 1

        costs = profits.flatten()
        supply_constraints = np.hstack([np.eye(num_suppliers) for _ in range(num_consumers)])
        demand_constraints = np.hstack([np.eye(num_consumers) for _ in range(num_suppliers)])

        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}")
            return

        if res.success:
            optimal_transfers = np.round(res.x.reshape(num_suppliers, num_consumers))
            if total_supply < total_demand:
                optimal_transfers = optimal_transfers[:-1, :]
            elif total_demand < total_supply:
                optimal_transfers = optimal_transfers[:, :-1]

            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()