#include <iostream>
#include <functional>
#include "tools/matrix.h"
#include "tools/math.h"
#include "simplex.h"

void _printInitialInputs(Vector& C, Matrix& A, Vector& b, double eps, bool maximize) {
	std::cout << "Running for the following inputs:" << std::endl << std::endl;
    std::cout << "epsilon: " << eps << std::endl;
    if (maximize)
    {
        std::cout << "Maximize" << std::endl;
    }
    else {
        std::cout << "Minimize" << std::endl;
    }
    std::cout << "z = ";
    bool previousIsNegative = false;
    for (size_t i = 0; i < C.size(); i++)
    {
        bool isNegative = false;
        if (C[i] != 0){
            if (i != 0 && !previousIsNegative){
                std::cout << " + ";
            }
                if (C[i] != 1) {
                    if (C[i] < 0){
                        isNegative = true;
                        std::cout << "(";
                    }
                    std::cout << C[i] << " * ";
                }
                
            std::cout << "x" << i + 1;
            if (isNegative){
                std::cout << ")";
            }
            
        }else {
            previousIsNegative = true;
        }
        
    }
    std::cout << std::endl << "subject to the constrains:" << std::endl;
    std::cout<< std::endl;
    for (size_t i = 0; i < b.size(); i++)
    {
        bool previousIsZero = false;
        for (size_t j = 0; j < A.getColumns(); j++)
        {
            bool isNegative = false;
            
            if (A[i][j] != 0) {
                if (j != 0  && !previousIsZero){
                    std::cout << " + ";
                    previousIsZero = false;
                }
                if (A[i][j] != 1) {
                    if (A[i][j] < 0) {
                        isNegative = true;
                        std::cout << "(";
                    }
                    std::cout << A[i][j] << " * ";
                }
                std::cout << "x" << j + 1;
                if (isNegative) {
                    std::cout << ")";
                }
                
            }else {
                previousIsZero = true;
            }
            
        }
        std::cout << " <= " << b[i] << std::endl;
        
    }
    


}


int printResult(Result result) {

    if (result.state == unsolvable) {
        std::cout << "The method is not applicable!" << std::endl;
    }else {
        std::cout << "SOLVED!" << std::endl;
        std::cout << "Decision variables: [";
        for (size_t i = 0; i < result.solution.size(); i++)
        {
            std::cout << result.solution[i];
            if (i != result.solution.size()-1){
                std::cout << ", ";
            }
        }
        std::cout << "]";
        std::cout << std::endl;
        if (result.maximize)
        {
            std::cout << "Maximum ";
        }else{
            std::cout << "Minimum ";
        }
        std::cout << "objective function value: " << result.objective_function_value << std::endl;
    }
    
    return 0;
}

bool check_eq(double a, double b, double relativeEpsilon = 0.0001) {
    double diff = std::abs(a - b);
    a = std::abs(a);
    b = std::abs(b);
    double largest = (b > a) ? b : a;

    return diff <= largest * relativeEpsilon;
}

int TEST_GENERAL_CASE() {
    std::cout << "----------------------------RUNNING_TEST_GENERAL_CASE----------------------------" << std::endl;

    Vector C = {5, 4};
    Matrix A = {
        {6, 4},
        {1, 2},
        {-1, 1},
        {0, 1}
    };
    Vector b = {24, 6, 1, 2};
    _printInitialInputs(C, A, b, 0.01, true);

    auto result = simplex(C, A, b);

    if (!(result.state == bounded)) {
        std::string state_name;
        switch (result.state) {
        case unsolvable:
            state_name = "unsolvable";
            break;
        case unbounded:
            state_name = "unbounded";
            break;
        default:
            state_name = "bounded";
            break;
        }
        std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
        return 0;
    }

    if (!check_eq(result.objective_function_value, 21)) {
        std::cout << "Incorrect objective function value. Expected 21. Got " //ЭТО УДАЛИТЬ?
                  << result.objective_function_value << std::endl;
        return 0;
    }

    if (!( check_eq(result.solution[0],3) && check_eq(result.solution[1], 1.5) )) {
        std::cout << "Incorrect desire variables. Expected 3 and 1.5. Got " //ЭТО УДАЛИТЬ?
                  << result.solution;
        return 0;
    }

    printResult(result);
    
    return 1;
}

int TEST_MINIMIZE_CASE() {
    std::cout << "----------------------------RUNNING_TEST_MINIMIZE_CASE----------------------------" << std::endl;

    Vector C = {-2, 2, -6};
    Matrix A = {
        {2, 1, -2},
        {1, 2, 4},
        {1, -1, 2}
    };
    Vector b = {24, 23, 10};
    _printInitialInputs(C, A, b, 0.01, false);

    auto result = simplex(C, A, b, 0.01, false);

    if (!(result.state == bounded)) {
        std::string state_name;
        switch (result.state) {
        case unsolvable:
            state_name = "unsolvable";
            break;
        case unbounded:
            state_name = "unbounded";
            break;
        default:
            state_name = "bounded";
            break;
        }
        std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
        return 0;
    }

    if (!check_eq(result.objective_function_value, -30.75)) {
        std::cout << "Incorrect objective function value. Expected -30.75. Got "
                  << result.objective_function_value << std::endl;
        return 0;
    }

    if (!( check_eq(result.solution[0], 0) && check_eq(result.solution[1], 0.75)
        && check_eq(result.solution[2],5.375)
    )) {
        std::cout << "Incorrect desire variables. Expected 3 and 1.5. Got "
                  << result.solution;
        return 0;
    }

    printResult(result);

    return 1;
}

int TEST_WITH_SLACK_CASE() {
    std::cout << "----------------------------RUNNING_TEST_WITH_SLACK_CASE----------------------------" << std::endl;

    Vector C = {5, 4};
    Matrix A = {
        {6, 4, 1},
        {1, 2, 0},
        {-1, 1, 0},
        {0, 1, 0}
    };
    Vector b = {24, 6, 1, 2};

    _printInitialInputs(C, A, b, 0.01, true);

    auto result = simplex(C, A, b);

    if (!(result.state == bounded)) {
        std::string state_name;
        switch (result.state) {
        case unsolvable:
            state_name = "unsolvable";
            break;
        case unbounded:
            state_name = "unbounded";
            break;
        default:
            state_name = "bounded";
            break;
        }
        std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
        return 0;
    }

    if (result.objective_function_value != 21) {
        std::cout << "Incorrect objective function value. Expected 21. Got "
                  << result.objective_function_value << std::endl;
        return 0;
    }

    if (!((result.solution[0] == 3) || (result.solution[1] == 1.5))) {
        std::cout << "Incorrect desire variables. Expected 3 and 1.5. Got "
                  << result.solution[0] << result.solution[1];
        return 0;
    }
    
    printResult(result);


    return 1;
}

int TEST_UNBOUNDED_CASE() {
    std::cout << "----------------------------RUNNING_TEST_UNBOUNDED_CASE----------------------------" << std::endl;

    Vector C = {2, 1};
    Matrix A = {
        {1, -1},
        {2, 0}
    };
    Vector b = {10, 40};
    
    _printInitialInputs(C, A, b, 0.01, true);

    auto result = simplex(C, A, b);

    if (!(result.state == unbounded)) {
        std::string state_name;
        switch (result.state) {
        case unsolvable:
            state_name = "unsolvable";
            break;
        case unbounded:
            state_name = "unbounded";
            break;
        default:
            state_name = "bounded";
            break;
        }
        std::cout << "Incorrect state type. Expected unbounded. Got " << state_name << std::endl;
        return 0;
    }
    
    printResult(result);

    return 1;
}

int TEST_UNSOLVABLE_CASE() {
    std::cout << "----------------------------RUNNING_TEST_UNSOLVABLE_CASE----------------------------" << std::endl;

    Vector C = {5, 4};
    Matrix A = {
        {6, 4},
        {1, 2},
        {-1, 1},
        {0, 1}
    };
    Vector b = {-24, 6, 1, 2};

    _printInitialInputs(C, A, b, 0.01, true);

    auto result = simplex(C, A, b);

    if (!(result.state == unsolvable)) {
        std::string state_name;
        switch (result.state) {
        case unsolvable:
            state_name = "unsolvable";
            break;
        case unbounded:
            state_name = "unbounded";
            break;
        default:
            state_name = "bounded";
            break;
        }
        std::cout << "Incorrect state type. Expected unsolvable. Got " << state_name << std::endl;
        return 0;
    }
    
    printResult(result);

    return 1;
}



int main() {

    std::vector<std::function<int(void)>> tests = {
        TEST_GENERAL_CASE,
        TEST_MINIMIZE_CASE,
        TEST_WITH_SLACK_CASE,
        TEST_UNBOUNDED_CASE,
        TEST_UNSOLVABLE_CASE
    };

    int counter = 0;

    for (auto& test : tests) {
        counter += test();
    }

    std::cout << "----------------------------RESULTS----------------------------" << std::endl;
    std::cout << "Total number of tests: " << tests.size() << std::endl;
    std::cout << "Total number of passed tests: " << counter << std::endl;

    return 0;
}