import numpy as np
from typing import Optional
from enum import Enum

# M constant
M = 1_000_000


class State(Enum):
    SOLVED = 0
    UNSOLVED = 1
    UNAPPLICABLE = 2


class Result:
    solved: State
    objective_function_value: Optional[np.int64]
    solution: Optional[np.array]

    def __init__(self,
                 solved: State,
                 objective_function_value: Optional[np.array] = None,
                 solution: np.int64 = None):
        self.solved = solved
        self.objective_function_value = objective_function_value
        self.solution = solution


def NorthwestCorner(
        S: np.array,
        C: np.array,
        D: np.array) -> Result:
    # TODO Northwest corner method
    pass



S = np.array([50, 60, 50, 50])

C = np.array([
    [16, 16, 13, 22, 17], 
    [14, 14, 13, 19, 15], 
    [19, 19, 20, 23, M ], 
    [M,  0,  M,  0,  0]])

D = np.array([30, 20, 70, 30, 60])


def Vogel(
        S: np.array,
        C: np.array,
        D: np.array) -> Result:
    
    print(C)
    iteration = 0
    while(len(C[0]) > 1 and  len(C) > 1):
        iteration += 1
        C_map = dict()
        
        for y in range(len(C)):
            for x in range(len(C[0])):
                C_map[x,y] = C[y][x]
        
        C_length = len(C[0])
        C_height = len(C)
        
        print(f"C_length: {C_length}")
        print(f"C_height: {C_height}")
        
        RowD = np.array
        ColD = np.array
        

        RowD = np.resize(RowD, C_height)
        ColD = np.resize(ColD, C_length)
        
        #print(sorted(C[0]))
        #print(sorted(C[0])[0])
        #print(sorted(C[0])[1])
        

        #Finding differences
        for y in range(C_height):
            RowD[y] = abs(sorted(C[y])[0] - sorted(C[y])[1])
        for x in range(C_length):   
            ColD[x] = abs(sorted(C.T[x])[0] - sorted(C.T[x])[1])
        
        print(f"S: {S}")
        print(f"D: {D}")
        
        print(f"RowD: {RowD}")
        print(f"ColD: {ColD}")
        #Maximum difference
        maxD = max(np.concatenate((ColD, RowD)))
        
        
        target_array = np.array([])
        target_number = None
        row_index_to_eleminate = None
        column_index_to_eleminate = None
        
        print(f"maxD: {maxD}")
        
        '''if maxD in RowD:
            target_array = C[np.where(RowD == maxD)[0]][0]
            target_number = min(target_array)
            row_index_to_eleminate = np.where(target_array == target_number)[0][0]
            print(f"row {row_index_to_eleminate}")
            C = np.delete(C, row_index_to_eleminate, 0)
            S = np.delete(S, row_index_to_eleminate, 0)'''
        
        if maxD in RowD:
            print("in RowD")
            y = np.where(RowD == maxD)[0][0]
            target_array = C[np.where(RowD == maxD)[0]][0]
            target_number = min(target_array)
            print(f"target_number: {target_number}")
            x = np.where(target_array == target_number)[0][0]
            print(f"(x,y): {(x,y)}")
            print(f"D[x]:{D[x]}, S[y]:{S[y]}")
                
            if (D[x] >= S[y]): #TODO ?
                print("D[x] > S[y]")
                row_index_to_eleminate = y
                print(f"row_index_to_eleminate {row_index_to_eleminate}")
                selected_value = S[y]
                
                D[x] -= selected_value 
                
                C = np.delete(C, row_index_to_eleminate, 0)
                S = np.delete(S, row_index_to_eleminate, 0)
                
            else:
                print("D[x] <= S[y]")
                column_index_to_eleminate = x
                selected_value = D[x]
                
                S[y] -= selected_value 
                
                C = np.delete(C, column_index_to_eleminate, 1)
                D = np.delete(D, column_index_to_eleminate, 0)
        
        if maxD in ColD:
            print("in ColD")
            x = np.where(ColD == maxD)[0][0]
            target_array = C.T[np.where(ColD == maxD)[0]][0]
            target_number = min(target_array)
            print(f"target_number: {target_number}")
            y = np.where(target_array == target_number)[0][0]
            print(f"(x,y): {(x,y)}")
            print(f"D[x]:{D[x]}, S[y]:{S[y]}")
            
            if (D[x] >= S[y]): #TODO ?
                print("D[x] > S[y]")
                row_index_to_eleminate = y
                selected_value = S[y]
                
                D[x] -= selected_value 
                
                C = np.delete(C, row_index_to_eleminate, 0)
                S = np.delete(S, row_index_to_eleminate, 0)
                
            else:
                print("D[x] <= S[y]")
                column_index_to_eleminate = x
                selected_value = D[x]
                
                S[y] -= selected_value 
                
                C = np.delete(C, column_index_to_eleminate, 1)
                D = np.delete(D, column_index_to_eleminate, 0)
        print(f"target_array: {target_array}")
        print(f"selected_value: {selected_value}")
        
        
        
        print(C)
        
        #print(target_array)
        #print(maxD)
    
    
    
    
    
    # TODO Vogel's method
    pass

#Vogel(S,C,D)

def Russell(
        S: np.array,
        C: np.array,
        D: np.array) -> Result:
    selected = np.zeros(C.shape)
    remaining_rows = np.ones(C.shape[0], dtype=bool)
    remaining_cols = np.ones(C.shape[1], dtype=bool)
    x_0 = np.zeros(C.shape)
    while True:

        mask = np.outer(remaining_rows, remaining_cols)

        u = np.max(np.where(mask, C, -M), axis=1)
        v = np.max(np.where(mask, C, -M), axis=0)
        d = np.zeros(C.shape, dtype=np.int64)
        for i in range(C.shape[0]):
            for j in range(C.shape[1]):
                if selected[i][j]:
                    d[i][j] = M
                else:
                    d[i][j] = C[i][j] - u[i] - v[j]

        i, j = np.unravel_index(np.argmin(d, axis=None), d.shape)

        if (D[j] == 0):
            break

        if (S[i] >= D[j]):
            x_0[i][j] = D[j]
            S[i] -= D[j]
            D[j] = 0
            remaining_cols[j] = 0
        else:
            x_0[i][j] = S[i]
            D[j] -= S[i]
            S[i] = 0
            remaining_rows[i] = 0
        selected[i][j] = 1
    return x_0


def print_problem_statement(S, C, D) -> None:
    # TODO print table
    pass


def solve(
        S: np.array,
        C: np.array,
        D: np.array) -> int:

    print_problem_statement(S, C, D)

    if (np.sum(S) != np.sum(D)):
        print("The problem is not balanced!")
        return 1

    result1 = NorthwestCorner(S, C, D)
    result2 = Vogel(S, C, D)
    result3 = Russell(S, C, D)

    # TODO check for state (unappicable?)

    print(result1.solution, result2.solution, result3.solution)
    return 0


'''if __name__ == "__main__":
    C = np.array([
        [16, 16, 13, 22, 17],
        [14, 14, 13, 19, 15],
        [19, 19, 20, 23, M],
        [M, 0, M, 0, 0]
    ], dtype=np.int64)

    S = np.array([
        50, 60, 50, 50
    ])

    D = np.array([
        30, 20, 70, 30, 60
    ])

    print(Russell(S, C, D))
'''