//Setup some enum's
const Presidence = Object.freeze({
	General: "general",
	Row: "row",
	Highest: "highest",
	Lowest: "lowest"
})

const AppliesTo = Object.freeze({
    All: "all",
    None: "none",
    Capped: "capped",
    Uncapped: "uncapped"
})

const Oversight = Object.freeze({
    Win: "win",
    Tie: "tie",
    Watch: "watch",
    Ignore: "ignore"
})

const Capsource = Object.freeze({
    Row: "row",
    General: "general"
})

const TestResult = Object.freeze({
    Pass: "Pass",
    Fail: "Fail"
})

//Declare some readability constants
const ShouldApplyCap = true;
const GeneralCapIsEnabled = true;
const RowCapIsEnabled = true;


function newResult(shouldApplyCap, reasonNum, trueCap, capSource, myBidNum) {
    let result = {};
    result.shouldApplyCap = shouldApplyCap;
    result.reason = reasonNum;
    result.trueCap = trueCap;
    result.capSource = capSource;
    result.myBid = myBidNum;
    return result;
}

function getBidCapReasonForScenario(scenario) {
    return getBidCapReason(scenario[0], scenario[1], scenario[2], scenario[3], scenario[4], scenario[5], scenario[6], scenario[7], scenario[8]);
}

//The function from our main codebase
function getBidCapReason(generalCapIsEnabled, generalCap, capPresidence, applyPresidenceTo, oversightAction, rowCapIsEnabled, rowCap, tieBid, myBid) {
    let tieBidNum = Number(tieBid);
    let winBidNum = Number(tieBid) + 25;
    let generalCapNum = Number(generalCap);
    let rowCapNum = Number(rowCap);
    let myBidNum = Number(myBid);

    //Build our response object
    let results = newResult(false, 0, null, null, myBidNum);

    //WIP - LOTS of rules here - these are just the beginning.
    if(generalCapIsEnabled) {
        if(capPresidence == Presidence.General) {
            if(applyPresidenceTo == AppliesTo.All) {
 
                switch(oversightAction) {
                    case Oversight.Win:
                        if(winBidNum > generalCapNum) {
                            results = newResult(true, 1, generalCapNum, Capsource.General, generalCapNum);
                            return results;
                        }
                        //winBidNum <= generalCapNum
                        results = newResult(false, 2, generalCapNum, Capsource.General, myBidNum);
                        break;

                    case Oversight.Tie:
                        if(tieBidNum > generalCapNum) {
                            results = newResult(true, 3, generalCapNum, Capsource.General, generalCapNum);
                            return results;
                        }
                        //tieBidNum <= generalCapNum
                        results = newResult(false, 4, generalCapNum, Capsource.General, myBidNum);
                        break;

                    case Oversight.Watch:
                        results = newResult(false, 5, generalCapNum, Capsource.General, myBidNum);
                        break;

                    case Oversight.Ignore:
                        results = newResult(false, 6, generalCapNum, Capsource.General, myBidNum);
                        break;

                    default:
                        //We should never get here because all oversight actions have been covered.
                }
                return results;
            }
            else if(applyPresidenceTo == AppliesTo.None){

            }
            else if(applyPresidenceTo == AppliesTo.Capped){

            }
            else if(applyPresidenceTo == AppliesTo.Uncapped){

            }
            return results;
        }
        else if(capPresidence == Presidence.Row) {
            return results;
        }
        else if(capPresidence == Presidence.Highest){
            return results;
        }
        else if(capPresidence == Presidence.Lowest){
            return results;
        }
    }

    //If we made it here, generalCapIsEnabled is FALSE so no conflicts should exist
    //This means rowCaps are the winners if they are enabled.
    if(rowCapIsEnabled) {
        switch(oversightAction) {
            case Oversight.Win:
                if(winBidNum > rowCapNum) {
                    results = newResult(true, 101, rowCapNum, Capsource.Row, rowCapNum);
                    return results;
                }
                //winBidNum <= rowCapNum
                results = newResult(false, 102, rowCapNum, Capsource.Row, myBidNum);
                break;

            case Oversight.Tie:
                if(tieBidNum > rowCapNum) {
                    results = newResult(true, 103, rowCapNum, Capsource.Row, rowCapNum);
                    return results;
                }
                //tieBidNum <= generalCapNum
                results = newResult(false, 104, rowCapNum, Capsource.Row, myBidNum);
                break;

            case Oversight.Watch:
                results = newResult(false, 105, null, Capsource.Row, myBidNum);
                break;

            case Oversight.Ignore:
                results = newResult(false, 106, null, Capsource.Row, myBidNum);
                break;
            default:
                //We should never get here because all oversight actions have been covered.
        }
        return results;
    }
    //Caps are not enabled for this row.

    return results;
}

//Stuff to Testing the actual functionality
function Assert(testName, thingsToCheck) {
    let allChecksPassed = true;
    let testCount = thingsToCheck.length;
    let testResults = [];
    for(let i = 0; i < testCount; i++ ){
        let result = (thingsToCheck[i] == true);
        testResults.push(result);
        if(!result) {
            allChecksPassed = false;
        }
    }
    let output = {};
    output.testName = testName;
    output.result = (allChecksPassed == true) ? TestResult.Pass: TestResult.Fail;
    output.individualResults = testResults;
    return output;
}

function executeTests(scenarios, expectations, verboseLevel) {
    ///////////////////////////////////////////////////////////////////////////////
    //Run thru the scenarios
    const scenariosCount = scenarios.length;
    console.log("VerboseLevel: "+ verboseLevel);
    console.log("Generating Scenarios...     \t[generalCapIsEnabled, generalCap, capPresidence, applyPresidenceTo, oversightAction,  rowCapIsEnabled, rowCap, tieBid, myBid]");
    console.log("Generating ExpectedValues...\t[shouldApplyCap, reason, trueCap, capSource, myBid]");
    if(verboseLevel >= 2) { console.log("Test \tScenarioValues -> ExpectedValues"); }
    console.log("--------------------------------------------------------");
    let scenarioReasons = [];
    for(let i = 0; i < scenariosCount; i++ ){
        if(verboseLevel >= 2) { console.log(i+"\t["+ scenarios[i]+"] -> "+ "["+expectations[i]+"]");}
        let reason = getBidCapReasonForScenario(scenarios[i]);
        scenarioReasons.push(reason);
    }

    ////////////////////////////////////////////////////////////////////////////////
    //Do the actual assertions/tests to confirm we got the results we were expecting
    const reasonsCount = scenarioReasons.length;
    console.log("");
    console.log("Running tests on each scenario...");
    if(verboseLevel >= 1){
        console.log("Test\tOutome\t||apply\t|reason\t|truCap\t|capSrc\t|myBid\t|| ScenarioValues -> ExpectedValues");
    } else {
        console.log("Test\tOutome\t|| ScenarioValues -> ExpectedValues");
    }
    console.log("-----------------------------------------------------------------");
    let allTestsPassed = true;
    let failCount = 0;
    for(let i = 0; i < reasonsCount; i++ ){
        //console.log(JSON.stringify(scenarioReasons[i]));
        let assertions = [
            (scenarioReasons[i].shouldApplyCap == expectations[i][0]),
            (scenarioReasons[i].reason == expectations[i][1]),
            (scenarioReasons[i].trueCap == expectations[i][2]),
            (scenarioReasons[i].capSource == expectations[i][3]),
            (scenarioReasons[i].myBid == expectations[i][4])
        ];
        let testResult = Assert(i, assertions);
        if(verboseLevel >= 1){
            let individualResults = testResult.individualResults.toString().replaceAll(",","\t| ");
            console.log(testResult.testName + "\t"+ testResult.result + "\t||"+ individualResults +"\t|| ["+scenarios[i]+"]\t-> ["+ expectations[i] +"]");
        } else {
            console.log(testResult.testName + "\t"+ testResult.result + "\t|| ["+scenarios[i]+"]\t-> ["+ expectations[i] +"]");
        }

        if(verboseLevel >= 2) {
            const ePad ="         \t |";
            const TestResult_ShouldApplyCap = (assertions[0] == true)? TestResult.Pass : TestResult.Fail;
            const TestResult_Reason = (assertions[1] == true)? TestResult.Pass : TestResult.Fail;
            const TestResult_TrueCap = (assertions[2] == true)? TestResult.Pass : TestResult.Fail;
            const TestResult_CapSource = (assertions[3] == true)? TestResult.Pass : TestResult.Fail;
            const TestResult_MyBid = (assertions[4] == true)? TestResult.Pass : TestResult.Fail;
            console.log("                 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            console.log(ePad +" ITEM         RESULT \t| ACTUAL \t| EXPECTED");
            console.log("                 +---------------------------------------------------");
            console.log(ePad +"shouldApplyCap: "+ TestResult_ShouldApplyCap +" \t| "+ scenarioReasons[i].shouldApplyCap +"  \t| "+ expectations[i][0]);
            console.log(ePad +"reason:         "+ TestResult_Reason   +"\t| "+ scenarioReasons[i].reason +"     \t| "+ expectations[i][1]);
            console.log(ePad +"trueCap:        "+ TestResult_TrueCap  +"\t| "+ scenarioReasons[i].trueCap  +"   \t| "+ expectations[i][2]);
            console.log(ePad +"capSource:      "+ TestResult_CapSource+"\t| "+ scenarioReasons[i].capSource   +"\t| "+ expectations[i][3]);
            console.log(ePad +"myBid:          "+ TestResult_MyBid    +"\t| "+ scenarioReasons[i].myBid    +"   \t| "+ expectations[i][4]);
            console.log("                 +---------------------------------------------------");
            console.log("---------------------------------------------------------------------");
        }

        if(testResult.result != TestResult.Pass){
            allTestsPassed = false;
            failCount++;
        }
    }
    console.log("=====================================================================");
    if(allTestsPassed){
        console.log("All "+reasonsCount +" tests passed");
    } else {
        console.log(failCount+"/"+reasonsCount+" tests failed");
    }
    console.log("");
    return allTestsPassed;
}


function getTest(testId) {
    //TODO: THIS CODE IS AN IDEA AND IS NOT USED YET
    let test = {};
    test.id = testId;
    test.given = getUseCases()[testId];
    test.expect = getExpectedOutcomes()[testId];
    return test;
}

//All the scenarios we could run into
function getUseCases(){
    let useCases = []; //[generalCapIsEnabled, generalCap, capPresidence, applyPresidenceTo, oversightAction,  rowCapIsEnabled, rowCap, tieBid, myBid];
    useCases[0] = [GeneralCapIsEnabled, 300, Presidence.General, AppliesTo.All, Oversight.Win, !RowCapIsEnabled, null, 500, 350];
    useCases[1] = [GeneralCapIsEnabled, 300, Presidence.General, AppliesTo.All, Oversight.Win,  RowCapIsEnabled, 450 , 500, 350];
    useCases[2] = [GeneralCapIsEnabled, 300, Presidence.General, AppliesTo.All, Oversight.Tie, !RowCapIsEnabled, null, 500, 350];
    useCases[3] = [GeneralCapIsEnabled, 300, Presidence.General, AppliesTo.All, Oversight.Tie,  RowCapIsEnabled, 450 , 500, 350];
    return useCases;
}

//And what we expect from each scenario
function getExpectedOutcomes(){
    let expectedOutcomes = []; //[shouldApplyCap, reason, trueCap, capSource, myBid]);
    expectedOutcomes[0] = [GeneralCapIsEnabled, 1, 300, Capsource.General, 300];
    expectedOutcomes[1] = [GeneralCapIsEnabled, 1, 300, Capsource.General, 300];
    expectedOutcomes[2] = [GeneralCapIsEnabled, 3, 300, Capsource.General, 300];
    expectedOutcomes[3] = [GeneralCapIsEnabled, 4, 300, Capsource.General, 300];
    return expectedOutcomes;
}


//Setup our scenarios and expected values
const useCases = getUseCases();
const expectedOutcomes = getExpectedOutcomes();
const verboseLevel = 1;

const testResults = executeTests(useCases, expectedOutcomes, verboseLevel);