package ru.kiselev;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class TransportTask {
    public static final String ANSI_RESET = "\u001B[0m";
    public static final String ANSI_RED = "\033[0;91m";
    public static void main(String[] args) {
        ArrayList<ArrayList<Integer>> MatrixCost= new ArrayList<ArrayList<Integer>>();
        ArrayList<ArrayList<Integer>> MatrixStockAndNeeds= new ArrayList<ArrayList<Integer>>();
        ArrayList<ArrayList<Integer>> MatrixOrder = new ArrayList<ArrayList<Integer>>();
        ReadFromFile(MatrixCost, MatrixStockAndNeeds, "Task.txt");
        int rangMatrix = MatrixCost.size() + MatrixCost.get(0).size() - 1;
        copyMatrix(MatrixOrder, MatrixCost);
        ZeroingMatrix(MatrixOrder);
        System.out.println("\nИсходная таблица\n");
        outputTable(MatrixCost, MatrixOrder, MatrixStockAndNeeds);
        int delta = CheckEqualsStocksAndNeeds(MatrixStockAndNeeds);
        if(delta != 0) {
            AddNewProviderOrStore(MatrixCost, MatrixOrder, MatrixStockAndNeeds, delta);
            outputTable(MatrixCost, MatrixOrder, MatrixStockAndNeeds);
        }
        System.out.print("\n********************Пошаговое решение********************\n");
        MethodNorthWestAngle(MatrixCost, MatrixOrder, MatrixStockAndNeeds);
        System.out.print("\n*********************************************************\n");
        System.out.println("\nИтоговая таблица\n");
        outputTable(MatrixCost, MatrixOrder, MatrixStockAndNeeds);
        resultCost(rangMatrix,MatrixCost,MatrixOrder);
    }
    private static void copyMatrix(ArrayList<ArrayList<Integer>> MatrixOrder, ArrayList<ArrayList<Integer>> MatrixCost){
        for(int i = 0; i < MatrixCost.size(); i++){
            MatrixOrder.add(new ArrayList<Integer>());
            for(int j = 0; j < MatrixCost.get(0).size(); j++){
                MatrixOrder.get(i).add(0);
            }
        }
    }

    private static void ZeroingMatrix(ArrayList<ArrayList<Integer>> MatrixOrder) {
        for (ArrayList<Integer> integers : MatrixOrder) {
            for (int j = 0; j < MatrixOrder.get(0).size(); j++) {
                integers.set(j, 0);
            }
        }
    }

    public static void ReadFromFile(ArrayList<ArrayList<Integer>> MatrixCost,
                                    ArrayList<ArrayList<Integer>> MatrixStockAndNeeds,
                                    String file){
        try {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String string = reader.readLine();
            String nextString = null;
            String[] separated = null;
            MatrixStockAndNeeds.add(new ArrayList<Integer>());
            MatrixStockAndNeeds.add(new ArrayList<Integer>());
            int rowCounter = 0;
            while((nextString = reader.readLine()) != null){
                MatrixCost.add(new ArrayList<Integer>());
                separated = string.split(" ");
                for(int i = 0; i < separated.length; i++){
                    if((i + 1) == separated.length){
                        MatrixStockAndNeeds.get(0).add(Integer.valueOf(separated[i]));
                        System.out.print(" " + MatrixStockAndNeeds.get(0).get(rowCounter) + "\n");
                        continue;
                    }
                    MatrixCost.get(rowCounter).add(Integer.valueOf(separated[i]));
                    System.out.print(" " + MatrixCost.get(rowCounter).get(i));
                }
                string = nextString;
                rowCounter++;
            }
            separated = string.split(" ");
            for(int i = 0; i < separated.length; i++){
                MatrixStockAndNeeds.get(1).add(Integer.valueOf(separated[i]));
                System.out.print(" " + MatrixStockAndNeeds.get(1).get(i) );
            }
            System.out.println();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void outputTable(ArrayList<ArrayList<Integer>> MatrixCost,
                                   ArrayList<ArrayList<Integer>> MatrixOrder,
                                   ArrayList<ArrayList<Integer>> MatrixStockAndNeeds){
        System.out.println("\t\t\t\t\t\t Магазины");
        System.out.print("Поставщики" + " |");
        for (int i = 0; i < MatrixCost.get(0).size(); i++){
            System.out.print("  B" + (i+1) +"  |");
        }
        System.out.println(" Запасы" + " | ");
        System.out.println("--------------------------------------------------------");
        for (int  i = 0; i < MatrixCost.size() + 1; i++){

            if(i < MatrixCost.size()){
                System.out.print("\t A" + (i+1) + "\t   |");
                for (int j = 0; j < MatrixCost.get(0).size() + 1; j++){
                    if(j < MatrixCost.get(0).size()){
                        System.out.printf("%6d|", MatrixCost.get(i).get(j));
                    }else{
                        System.out.println("\t\t   |");
                    }

                }
                System.out.print("\t\t   |");
                for (int j = 0; j < MatrixOrder.get(0).size() + 1; j++){
                    if(j < MatrixOrder.get(0).size()){
                        if(MatrixOrder.get(i).get(j) > 0){
                            System.out.printf(ANSI_RED+ "%-6d"+ANSI_RESET+"|", MatrixOrder.get(i).get(j));
                        }else{
                            System.out.printf("%-6d|", MatrixOrder.get(i).get(j));
                        }
                    }else{
                        System.out.printf("%8d|", MatrixStockAndNeeds.get(0).get(i));
                    }

                }
                System.out.println();
                System.out.println("--------------------------------------------------------");
            }else{
                System.out.print("Потребности|");
                for (int j = 0; j < MatrixOrder.get(0).size() + 1; j++){
                    if(j < MatrixOrder.get(0).size()) {
                        System.out.printf("%-6d|", MatrixStockAndNeeds.get(1).get(j));
                    }else{
                        System.out.printf("%8d|", CheckEqualsStocksAndNeeds(MatrixStockAndNeeds));
                    }
                }
            }
        }
        System.out.println("\n");
    }
    public static void MethodNorthWestAngle(ArrayList<ArrayList<Integer>> MatrixCost,
                                            ArrayList<ArrayList<Integer>> MatrixOrder,
                                            ArrayList<ArrayList<Integer>> MatrixStockAndNeeds){
        int min;
        for(int i = 0; i < MatrixCost.size(); i++){
            for(int j = 0; j < MatrixCost.get(0).size(); j++){
                if(checkEmptyNeeds(MatrixStockAndNeeds,j)) continue;
                min = Math.min(MatrixStockAndNeeds.get(0).get(i),MatrixStockAndNeeds.get(1).get(j));
                MatrixStockAndNeeds.get(0).set(i,MatrixStockAndNeeds.get(0).get(i) - min);
                MatrixStockAndNeeds.get(1).set(j,MatrixStockAndNeeds.get(1).get(j) - min);
                MatrixOrder.get(i).set(j,min);
                outputTable(MatrixCost, MatrixOrder, MatrixStockAndNeeds);
                if(checkEmptyStock(MatrixStockAndNeeds,i)) break;
            }
        }
    }
    public static boolean checkEmptyStock(ArrayList<ArrayList<Integer>> MatrixStockAndNeeds,int RowStock){
        return MatrixStockAndNeeds.get(0).get(RowStock) == 0;
    }

    public static boolean checkEmptyNeeds(ArrayList<ArrayList<Integer>> MatrixStockAndNeeds,int ColumnNeeds){
        return MatrixStockAndNeeds.get(1).get(ColumnNeeds) == 0;
    }
    // возвращает разность между поставщиком и магазином,
    // если пришло отрицательное то добавляем такого поставщика,
    // если положительное то такой магазин, если ноль то successful
    public static int CheckEqualsStocksAndNeeds(ArrayList<ArrayList<Integer>> MatrixStockAndNeeds){
        int summStocks = 0;
        int summNeeds = 0;
        for(int i = 0; i < MatrixStockAndNeeds.get(0).size(); i++){
            summStocks += MatrixStockAndNeeds.get(0).get(i);
        }
        for(int i = 0; i < MatrixStockAndNeeds.get(1).size(); i++){
            summNeeds += MatrixStockAndNeeds.get(1).get(i);
        }
        return summStocks - summNeeds;
    }
    public static void AddNewProviderOrStore(ArrayList<ArrayList<Integer>> MatrixCost,
                                             ArrayList<ArrayList<Integer>> MatrixOrder,
                                             ArrayList<ArrayList<Integer>> MatrixStockAndNeeds,
                                             int deltaStockAndNeeds){
        if(deltaStockAndNeeds < 0){ // Новый поставщик
            System.out.println("\nБыл добавлен новый поставщик\n");
            deltaStockAndNeeds = Math.abs(deltaStockAndNeeds);
            MatrixCost.add(new ArrayList<Integer>());
            MatrixOrder.add(new ArrayList<Integer>());
            for (int i = 0; i < MatrixCost.get(0).size(); i++){
                MatrixCost.get(MatrixCost.size()-1).add(0);
                MatrixOrder.get(MatrixOrder.size()-1).add(0);
            }
            MatrixStockAndNeeds.get(0).add(deltaStockAndNeeds);
        }else{ // Новый магазин
            System.out.println("\nБыл добавлен новый магазин\n");
            for(int i = 0; i < MatrixCost.size(); i++){
                MatrixCost.get(i).add(0);
                MatrixOrder.get(i).add(0);
            }
            MatrixStockAndNeeds.get(1).add(deltaStockAndNeeds);
        }

    }
    public static void resultCost(int rangMatrix, ArrayList<ArrayList<Integer>> MatrixCost, ArrayList<ArrayList<Integer>> MatrixOrder){
        int Z = 0;
        int filledCeils = countFilledCeils(MatrixOrder);
        System.out.println("Ранг исходной матрицы равен = " + rangMatrix + " Заполненных клеток в таблице равно = " + filledCeils);
        if (rangMatrix != filledCeils) System.out.println("Где то ты оступился...");
        System.out.print("Результат алгоритма Zmin = ");
        for(int i = 0; i < MatrixOrder.size(); i++){
            for(int j = 0; j < MatrixOrder.get(0).size(); j++){
                if(MatrixOrder.get(i).get(j) > 0) {
                    System.out.print("("+ MatrixOrder.get(i).get(j) +" * "+ MatrixCost.get(i).get(j) +")");
                    if(i < MatrixOrder.size()-1 && j < MatrixOrder.get(0).size()) System.out.print("+");
                    Z+= MatrixOrder.get(i).get(j) * MatrixCost.get(i).get(j);
                }
            }
        }
        System.out.println(" = " + Z);

    }
    public static int countFilledCeils(ArrayList<ArrayList<Integer>> MatrixOrder){
        int filledCeils = 0;
        for(int i = 0; i < MatrixOrder.size(); i++){
            for(int j = 0; j < MatrixOrder.get(0).size(); j++){
                if(MatrixOrder.get(i).get(j) > 0) filledCeils++;
            }
        }
        return filledCeils;
    }
}