let Common   = system.getScript("/driverlib/Common.js");
let Pinmux   = system.getScript("/driverlib/pinmux.js");

/* Intro splash on GUI */
let longDescription = "CAN is a communication peripheral which is used " +
    "when there is high noise in the signal bus. It uses a differential " +
    "wire topology to reduce the common noise. This applicatoin provides " +
    "a simplified interface to configure the different parameters of the " +
    "peripheral such as bit rate, time quanta and test mode etc. ";

function onChangeUseLoopback(inst, ui)
{
    if (inst.enableLoopback) {
        ui.loopbackMode.hidden = false;
    }
    else {
        ui.loopbackMode.hidden = true;
    }
}
function onChangeUseAutoBusOn(inst, ui)
{
    if (inst.enableAutoBusOn) {
        ui.AutoBusOnTimer.hidden = false;
    }
    else {
        ui.AutoBusOnTimer.hidden = true;
    }
}
function onChangeEnableInterrupt(inst, ui)
{
    if (inst.enableInterrupt) {
        ui.registerInterrupts.hidden = false;
        ui.interruptFlags.hidden = false;
        ui.interruptLine.hidden = false;
    }
    else {
        ui.registerInterrupts.hidden = true;
        ui.interruptFlags.hidden = true;
        ui.interruptLine.hidden = true;
    }
}

var msgCountConfig = []
for (var msgCount = 1; msgCount <= 32; msgCount++)
{
    msgCountConfig.push(
        {
            name: msgCount ,
            displayName: msgCount.toString()
        }
    );
}
var SysClk_MHz = Common.SYSCLK_getMaxMHz();
var SysClk_Hz = SysClk_MHz * 1000000;
var bitTimeOptions = [];
for (var bitTime = 8; bitTime <= 25; bitTime++)
{
    bitTimeOptions.push(
        {
            name: bitTime ,
            displayName: bitTime.toString()
        }
    );
}
var tSeg1 = 0;
var tSeg2 = 0;
var sjw = 0;
var prescalerExtension = 0, prescaler = 0;
var bitTime = 8;

function calcBitTimeParam(bitRate)
{
    for (var i = 17; i >= 0; i--)
    {
        bitTime = i + 8;
        var brp = (SysClk_Hz/(bitRate*bitTime)), tProp = 2, tSync = 1, tPhase = bitTime - (tSync + tProp), phaseSeg1 = 0, phaseSeg2 = 0;
        if((tPhase / 2) <= 8)
        {
            phaseSeg2 = tPhase / 2;
        }
        else
        {
            phaseSeg2 = 8;
        }
        tSeg1 = ((tPhase - phaseSeg2) + tProp) - 1;
        tSeg2 = phaseSeg2 - 1;
        sjw = 0;
        prescalerExtension = 0; prescaler = 0;
        if(phaseSeg2 > 4)
        {
            sjw = 3;
        }
        else
        {
            sjw = tSeg2;
        }
        prescalerExtension = parseInt((brp - 1) / 64);
        prescaler = ((brp - 1) % 64);
        if(Number.isInteger(brp))
        {
            return;
        }
    }
}
function onChangeBitRate(inst, ui)
{
    SysClk_Hz = inst.sysClock*1000000;
    calcBitTimeParam(inst.bitRate);
    inst.bitTime = bitTime;
    inst.bitRatePrescalerExtension = prescalerExtension;
    inst.bitRatePrescaler = prescaler;
    inst.bitTimeSeg1 = tSeg1;
    inst.bitTimeSeg2 = tSeg2;
    return;
}

calcBitTimeParam(500000);

function onChangeAutoCalc(inst, ui)
{
    if(inst.bitTimeAutoCalc)
    {
        ui.bitTime.readOnly = true;
        ui.bitTimeSeg1.readOnly = true;
        ui.bitTimeSeg2.readOnly = true;
        ui.bitRatePrescaler.readOnly = true;
        ui.bitRatePrescalerExtension.readOnly = true;
        ui.sjw.readOnly = true;
        onChangeBitRate(inst, ui);
    }
    else
    {
        ui.bitTime.readOnly = false;
        ui.bitTimeSeg1.readOnly = false;
        ui.bitTimeSeg2.readOnly = false;
        ui.bitRatePrescaler.readOnly = false;
        ui.bitRatePrescalerExtension.readOnly = false;
        ui.sjw.readOnly = false;
    }
}

let config = [
    {
        name: "GROUP_BR",
        displayName: "Bit Rate Parameters",
        config: [
        {
            name        : "sysClock",
            displayName : "Device SYSCLK MHz",
            description : 'Device System Clock Frequency',
            hidden      : false,
            default     : SysClk_MHz,
            onChange    : onChangeBitRate,
        },
        {
            name        : "bitRate",
            displayName : "Bit Rate Bps",
            description : 'CAN bus bit rate',
            hidden      : false,
            default     : "500000",
            onChange    : onChangeBitRate,
            options     :[
                {name: "1000000", displayName : "1000000"},
                {name: "800000", displayName : "800000"},
                {name: "500000", displayName : "500000"},
                {name: "250000", displayName : "250000"},
                {name: "125000", displayName : "125000"},
                {name: "100000", displayName : "100000"},
                {name: "50000", displayName : "50000"},
            ],
        },
        {
            name        : "bitTimeAutoCalc",
            displayName : "Use Calculated Values for Bit Timing Parameters",
            description : 'Use Calculated Values for Bit Timing Parameters',
            hidden      : false,
            onChange    : onChangeAutoCalc,
            default     : true,

        },
        {
            name        : "bitTime",
            displayName : "Bit Time Quanta (Tq)",
            description : 'Number of time quanta per bit',
            hidden      : false,
            default     : bitTimeOptions[bitTime-8].name,
            options     : bitTimeOptions,
            readOnly    : true,

        },
        {
            name        : "bitRatePrescalerExtension",
            displayName : "Bit Rate Prescelar Extension",
            description : 'Bit Rate Prescelar Extension',
            hidden      : false,
            default     : prescalerExtension,
            readOnly    : true,

        },
        {
            name        : "bitRatePrescaler",
            displayName : "Bit Rate Prescaler",
            description : 'Bit Rate Prescaler',
            hidden      : false,
            default     : prescaler,
            readOnly    : true,

        },
        {
            name        : "bitTimeSeg1",
            displayName : "Bit Time segment before sample point (Tq)",
            description : 'Bit Time segment before sample point (Tq)',
            hidden      : false,
            default     : tSeg1,
            readOnly    : true,

        },
        {
            name        : "bitTimeSeg2",
            displayName : "Bit Time segment after sample point (Tq)",
            description : 'Bit Time segment after sample point (Tq)',
            hidden      : false,
            default     : tSeg2,
            readOnly    : true,

        },
        {
            name        : "sjw",
            displayName : "(Re)Synchronization Jump Width (Tq)",
            description : '(Re)Synchronization Jump Width (Tq)',
            hidden      : false,
            default     : sjw,
            readOnly    : true,

        },
        ]
    },
    {
        name        : "enableLoopback",
        displayName : "Enable Loopback",
        description : 'Whether loopback mode to be enabled.',
        hidden      : false,
        onChange    : onChangeUseLoopback,
        default     : false,
    },
    {
        name        : "loopbackMode",
        displayName : "Loopback Mode",
        description : 'Which loopback mode to use if enabled.',
        hidden      : true,
        default     : "CAN_TEST_SILENT",
        options     : [
            {name: "CAN_TEST_SILENT", displayName : "Silent Mode"},
            {name: "CAN_TEST_LBACK", displayName : "Internal Loopback Mode"},
            {name: "CAN_TEST_EXL", displayName : "External Loopback Mode"},
        ],

    },
    {
        name        : "enableAutoBusOn",
        displayName : "Enable Auto-Bus-On",
        description : 'Whether auto bus on feature is to be enabled.',
        hidden      : false,
        onChange    : onChangeUseAutoBusOn,
        default     : false,
    },
    {
        name        : "AutoBusOnTimer",
        displayName : "Auto-Bus-On Timer",
        description : 'Auto-Bus-On Timer value if enabled.',
        hidden      : true,
        default     : 0,

    },
    {
        name: "GROUP_INT",
        displayName: "Interrupts",
        config: [
            {
                name        : "enableInterrupt",
                displayName : "Enable Interrupt",
                description : 'To Enable CAN Interrupts.',
                hidden      : false,
                onChange    : onChangeEnableInterrupt,
                default     : false,
            },
            {
                name        : "registerInterrupts",
                displayName : "Register Interrupt Handler",
                description : 'Whether or not to register interrupt handlers in the interrupt module.',
                hidden      : true,
                default     : false

            },
            {
                name        : "interruptFlags",
                displayName : "Enable Interrupts",
                description : 'Which Interrupts to enable.',
                hidden      : true,
                minSelections : 0,
                default     : [],
                options     : [
                    {name: "CAN_INT_ERROR", displayName : "Controller error condition "},
                    {name: "CAN_INT_STATUS", displayName : "Message transfer complete or bus error"},
                    {name: "CAN_INT_IE0", displayName : "Enable CAN line 0 Interrupts"},
                    {name: "CAN_INT_IE1", displayName : "Enable CAN line 1 Interrupts"},
                ],

            },
            {
                name        : "interruptLine",
                displayName : "Enable Global Interrupt Lines",
                description : 'Which Interrupt lines to enable.',
                hidden      : true,
                minSelections : 0,
                default     : [],
                options     : [
                    {name: "CAN_GLOBAL_INT_CANINT0", displayName : "Enable CAN Global Interrupt line 0"},
                    {name: "CAN_GLOBAL_INT_CANINT1", displayName : "Enable CAN Global Interrupt line 1"},
                ],

            },
        ]
    },
    {
        deprecated  : true,
        name        : "msgObjs",
        displayName : "Message Objects",
        description : 'Message objects need to be configured',
        hidden      : false,
        default     : 0,
        onChange    : (inst, ui) => {
            var convertedArray = []
            for (var mO = 1; mO <= inst["msgObjs"]; mO++)
            {
                convertedArray.push(mO);
            }
            inst["msgObjsUsed"] = convertedArray;
        }
    },
    {
        name        : "msgObjsUsed",
        displayName : "Message Objects used (1-32)",
        description : 'Message objects need to be configured',
        hidden      : false,
        minSelections : 0,
        default     : [],
        options     : msgCountConfig
    },
    {
        name: "useCase",
        displayName : "PinMux Use Case",
        description : 'Peripheral use case',
        hidden      : false,
        default     : 'ALL',
        options     : Pinmux.getPeripheralUseCaseNames("CAN"),
        onChange    : Pinmux.useCaseChanged,
    },
    {
        name : "startModule",
        displayName : "Start CAN module in CAN_init() function",
        description : "Starts the CAN Module",
        hidden      : false,
        default     : true,
    },
];

function moduleInstances(inst,ui)
{
    let components = [];

    var pinmuxQualMods = Pinmux.getGpioQualificationModInstDefinitions("CAN", inst)
    for (var pinmuxQualMod of pinmuxQualMods)
    {
        pinmuxQualMod.args.padConfig = "PULLUP";

        if(pinmuxQualMod.name.includes("rx"))
        {
            pinmuxQualMod.requiredArgs = {
                qualMode : "GPIO_QUAL_ASYNC",
            }
        }
        else
        {
            pinmuxQualMod.args.qualMode = "GPIO_QUAL_ASYNC";
        }
    }
    components = components.concat(pinmuxQualMods)

    for(var i in inst.msgObjsUsed)
    {
        components = components.concat([
        {
            moduleName : "/driverlib/canMsgObj.js",
            name : "msgObj"+inst.msgObjsUsed[i],
            displayName: "Message Object "+inst.msgObjsUsed[i],
            collapsed : true,
        },
        ]);
    }
    if (inst.enableInterrupt && inst.registerInterrupts)
    {
        components = components.concat([{
            name: "can0Int",
            displayName: "CAN Interrupt 0",
            moduleName: "/driverlib/interrupt.js",
            collapsed: true,
            args: {
                $name : inst.$name + "_0_INT",
                int : "INT_" + inst.$name + "_0",
                pinmuxPeripheralModule : "can",
                driverlibInt: "INT_#0"
            }
        },
        {
            name: "can1Int",
            displayName: "CAN Interrupt 1",
            moduleName: "/driverlib/interrupt.js",
            collapsed: true,
            args: {
                $name : inst.$name + "_1_INT",
                int : "INT_" + inst.$name + "_1",
                pinmuxPeripheralModule : "can",
                driverlibInt: "INT_#1"
            }
        }]);
    }
    return components;
}

/*
 *  ======== filterHardware ========
 *  Control RX, TX Pin usage by the user specified dataDirection.
 *
 *  param component - hardware object describing signals and
 *                     resources they're attached to
 *
 *  returns Boolean indicating whether or not to allow the component to
 *           be assigned to an instance's $hardware config
 */
function filterHardware(component)
{
    return (Common.typeMatches(component.type, ["CAN"]));
}

if (Common.onlyPinmux())
{
    config = [config[config.length - 1]];
}


function onValidate(inst, validation) {

    if ( inst.bitRatePrescaler >= 64 || inst.bitRatePrescaler < 0)
    {
        validation.logError(
            "The Bit Rate Prescaler must be a number between 0 and 64",
            inst, "bitRatePrescaler");
    }
    if ((inst.bitRatePrescalerExtension < 0) || (inst.bitRatePrescalerExtension >= 16))
    {
        validation.logError(
            "The Bit Rate Prescaler Extension value must be a number between 0 and 16",
            inst, "bitRatePrescalerExtension");
    }
    if ( inst.bitTimeSeg1 >= 16 || inst.bitTimeSeg1 <= 0)
    {
        validation.logError(
            "The Bit Time segment before sampling must be a number between 1 and 16",
            inst, "bitTimeSeg1");
    }
    if ( inst.bitTimeSeg2 >= 8 || inst.bitTimeSeg1 < 0)
    {
        validation.logError(
            "The Bit Time segment after sampling must be a number between 0 and 8",
            inst, "bitTimeSeg2");
    }
    if ( inst.sjw >= 4 || inst.sjw < 0)
    {
        validation.logError(
            "(Re)Synchronization Jump Width must be a number between 0 and 4",
            inst, "sjw");
    }
    if ( inst.sysClock != SysClk_MHz)
    {
        validation.logWarning(
            "Sysclk Frequency is not the default value of " + String(SysClk_MHz),
            inst, "sysClock");
    }
    if((String(inst.interruptFlags).includes("CAN_INT_IE0") || String(inst.interruptFlags).includes("CAN_INT_STATUS") || String(inst.interruptFlags).includes("CAN_INT_ERROR")) && !String(inst.interruptLine).includes("CAN_GLOBAL_INT_CANINT0"))
    {
        validation.logWarning("Line 0 Interrupts Enabled but Global Line 0 Not Enabled",
            inst, "interruptLine");
    }
    if(String(inst.interruptFlags).includes("CAN_INT_IE1") && !String(inst.interruptLine).includes("CAN_GLOBAL_INT_CANINT1"))
    {
        validation.logWarning("Line 1 Interrupt Enabled but Global Line 1 Not Enabled",
            inst, "interruptLine");
    }
    
    var pinmuxQualMods = Pinmux.getGpioQualificationModInstDefinitions("CAN", inst)
    for (var pinmuxQualMod of pinmuxQualMods)
    {
        if ((inst[pinmuxQualMod.name].padConfig.includes("OD")) || (inst[pinmuxQualMod.name].padConfig.includes("INVERT")))
        {
            validation.logError("The open-drain and inverted pad configurations should not be used for the CAN module.", inst);
        }
    }
}

var canModule = {
    peripheralName: "CAN",
    displayName: "CAN",
    maxInstances: Common.peripheralCount("CAN"),
    defaultInstanceName: "myCAN",
    description: "Controller Area Network Peripheral",
    longDescription: (Common.getCollateralFindabilityList("DCAN")),
    filterHardware : filterHardware,
    moduleInstances : moduleInstances,
    config: config,
    templates: {
        boardc : "/driverlib/can/can.board.c.xdt",
        boardh : "/driverlib/can/can.board.h.xdt"
    },
    validate: onValidate,
    pinmuxRequirements    : Pinmux.canPinmuxRequirements
};


if (canModule.maxInstances <= 0)
{
    delete canModule.pinmuxRequirements;
}
else
{
    Pinmux.addCustomPinmuxEnumToConfig(canModule)
    Pinmux.addPinMuxQualGroupToConfig(canModule)
}

exports = canModule;