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

let device_driverlib_peripheral = 
    system.getScript("/driverlib/device_driverlib_peripherals/" + 
        Common.getDeviceName().toLowerCase() + "_spi.js");

var pteOption = device_driverlib_peripheral.SPI_PTEPolarity;
if(!pteOption)
{
    pteOption = device_driverlib_peripheral.SPI_STEPolarity;
}

/* Intro splash on GUI */
let longDescription = "The Serial Peripheral Interface (SPI) "
    + "driver is a generic, full-duplex driver that transmits "
    + "and receives data on a SPI bus. SPI is sometimes called SSI "
    + "(Synchronous Serial Interface). The SPI protocol defines "
    + "the format of a data transfer over the SPI bus, but it "
    + "leaves flow control, data formatting, and handshaking "
    + "mechanisms to higher-level software layers."


function onChangeUseFIFO(inst, ui)
{
    onChangeUseInterrupts(inst, ui);
}


function onValidate(inst, validation) 
{   
    var bitRateError = false;
    try{
        var bitRateInt = parseInt(inst.bitRate);
        if (bitRateInt < 1 || bitRateInt > 50000000)
        {
            bitRateError = true;
        }
    }
    catch (ex){
        bitRateError = true;
    }
    if(bitRateError)
    {
        validation.logError(
            "Enter an integer for bit rates between 1 and LSPCLK/4!", 
            inst, "bitRate");
    }

    if (inst.useDMARX && inst.spiRXDMA.databusWidthConfig == "DMA_CFG_SIZE_32BIT") {
        validation.logError("32 bit databus width is not valid while linked to SPI!", inst.spiRXDMA, "databusWidthConfig");   
    }

    if (inst.useDMATX && inst.spiTXDMA.databusWidthConfig == "DMA_CFG_SIZE_32BIT") {
        validation.logError("32 bit databus width is not valid while linked to SPI!", inst.spiTXDMA, "databusWidthConfig");   
    }

    if ((inst.useDMATX || inst.useDMARX) && !inst.useFifo) {
        validation.logError("FIFO must be enabled for DMA linking!", inst, "useFifo");   
    }

    var pinmuxQualMods = Pinmux.getGpioQualificationModInstDefinitions("SPI", inst)
    for (var pinmuxQualMod of pinmuxQualMods)
    {
        if (inst[pinmuxQualMod.name].padConfig.includes("OD"))
        {
            validation.logError("The open-drain pad configuration should not be used for the SPI module.", inst);
        }
    }
}


function onChangeUseInterrupts(inst, ui)
{
    if (inst.useInterrupts)
    {
        ui.registerInterrupts.hidden = false;
        if (inst.useFifo)
        {
            ui.enabledFIFOInterrupts.hidden = false;
            ui.enabledInterrupts.hidden = true;

            ui.txFifo.hidden = false;
            ui.rxFifo.hidden = false;
        }
        else
        {
            ui.enabledFIFOInterrupts.hidden = true;
            ui.enabledInterrupts.hidden = false;

            ui.txFifo.hidden = true;
            ui.rxFifo.hidden = true;
        }
        
    }
    else
    {
        ui.registerInterrupts.hidden = true;

        ui.enabledFIFOInterrupts.hidden = true;
        ui.enabledInterrupts.hidden = true;
        
        ui.txFifo.hidden = true;
        ui.rxFifo.hidden = true;
    }

}

/* Array of SPI configurables that are common across device families */
let config = [
    
    {
        name        : "transferProtocol",
        displayName : "Transfer Protocol",
        description : 'Mode for transfer protocol',
        hidden      : false,
        default     : device_driverlib_peripheral.SPI_TransferProtocol[0].name,
        options     : device_driverlib_peripheral.SPI_TransferProtocol
    },

    {
        name        : "mode",
        displayName : "Mode",
        description : 'Mode for device',
        hidden      : false,
        default     : device_driverlib_peripheral.SPI_Mode[0].name,
        options     : device_driverlib_peripheral.SPI_Mode
    },

    {
        name        : "ptePolarity",
        legacyNames : ["stePolarity"],
        displayName : "PTE Polarity",
        description : 'Polarity of the PTE Pin',
        hidden      : false,
        default     : pteOption[0].name,
        options     : pteOption
    },

    {
        name        : "emulationMode",
        displayName : "Emulation Mode",
        description : 'Emulation Mode',
        hidden      : false,
        default     : device_driverlib_peripheral.SPI_EmulationMode[0].name,
        options     : device_driverlib_peripheral.SPI_EmulationMode
    },

    {
        name        : "bitRate",
        displayName : "Bit Rate (Hz)",
        description : 'Bit rate for device in (Hz). Cannot exceed LSPCLK/4',
        hidden      : false,
        default     : 25000
    },

    {
        name        : "dataWidth",
        displayName : "Data Width",
        description : 'Data width used for transmission',
        hidden      : false,
        default     : '16',
        options     : [
            {name: "1"},
            {name: "2"},
            {name: "3"},
            {name: "4"},
            {name: "5"},
            {name: "6"},
            {name: "7"},
            {name: "8"},
            {name: "9"},
            {name: "10"},
            {name: "11"},
            {name: "12"},
            {name: "13"},
            {name: "14"},
            {name: "15"},
            {name: "16"}
        ]
    },
    
    {
        name        : "useFifo",
        displayName : "Use FIFO",
        description : 'Whether or not to use FIFO mode.',
        hidden      : false,
        onChange    : onChangeUseFIFO,
        default     : true
        
    },

    {
        name        : "useInterrupts",
        displayName : "Use Interrupt",
        description : 'Whether or not to use Interrupt mode.',
        hidden      : false,
        onChange    : onChangeUseInterrupts,
        default     : true
        
    },
    {
        name        : "registerInterrupts",
        displayName : "Register Interrupt Handler",
        description : 'Whether or not to register interrupt handlers in the interrupt module.',
        hidden      : false,
        default     : false
        
    },

    {
        name        : "enabledInterrupts",
        displayName : "Enabled Interrupts",
        description : 'Which interrupts to enabled.',
        hidden      : true,
        default     : [],
        minSelections: 0,
        options     : [
            {name: "SPI_INT_RX_DATA_TX_EMPTY", displayName: "Receive Interrupt"},
            {name: "SPI_INT_RX_OVERRUN", displayName: "Receive Overrun Interrupt"},
        ],
        
    },

    {
        name        : "enabledFIFOInterrupts",
        displayName : "Enabled FIFO Interrupts",
        description : 'Which FIFO interrupts to enabled.',
        hidden      : false,
        default     : [],
        minSelections: 0,
        options     : [
            {name: "SPI_INT_RXFF", displayName: "Receive Interrupt"},
            {name: "SPI_INT_RXFF_OVERFLOW", displayName: "Receive Overflow Interrupt"},
            {name: "SPI_INT_TXFF", displayName: "Transmit Interrupt"},
        ],
        
    },

    {
        name        : "txFifo",
        displayName : "Transmit FIFO Interrupt Level",
        description : 'Transmit FIFO interrupt level used.',
        hidden      : false,
        default     : device_driverlib_peripheral.SPI_TxFIFOLevel[0].name,
        options     : device_driverlib_peripheral.SPI_TxFIFOLevel
    },

    {
        name        : "rxFifo",
        displayName : "Receive FIFO Interrupt Level",
        description : 'Receive FIFO interrupt level used.',
        hidden      : false,
        default     : device_driverlib_peripheral.SPI_RxFIFOLevel[0].name,
        options     : device_driverlib_peripheral.SPI_RxFIFOLevel
    },

    {
        name        : "loopback",
        displayName : "Use Loopback Mode",
        description : 'Whether or not to use loopback mode.',
        hidden      : false,
        default     : false
        
    },
    
    {
        name: "useCase",
        displayName : "Use Case",
        description : 'Peripheral use case',
        hidden      : false,
        default     : 'ALL',
        options     : Pinmux.getPeripheralUseCaseNames("SPI"),
        onChange    : Pinmux.useCaseChanged,
    },
];

if (["F28002x", "F28003x", "F28004x", "F2807x", "F2837xS", "F2837xD", "F2838x", "F28P65x"].includes(Common.getDeviceName())){
    config = config.concat([
        {
            name        : "useDMARX",
            displayName : "Use DMA for Receive",
            description : 'Whether or not to use DMA mode for RX.',
            hidden      : false,
            default     : false
        },
    
        {
            name        : "useDMATX",
            displayName : "Use DMA for Transmit",
            description : 'Whether or not to use DMA mode for TX.',
            hidden      : false,
            default     : false
        },
    ])
}

/*
 *  ======== 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, ["SPI"]));
}

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

var spiModule = {
    peripheralName: "SPI",
    displayName: "SPI",
    maxInstances: Common.peripheralCount("SPI"),
    defaultInstanceName: "mySPI",
    description: "Serial Peripheral Interface Peripheral",
    filterHardware : filterHardware,
    config: config,
    moduleInstances: (inst) => {
        var submodules = []

        var pinmuxQualMods = Pinmux.getGpioQualificationModInstDefinitions("SPI", inst)
        for (var pinmuxQualMod of pinmuxQualMods)
        {
            pinmuxQualMod.requiredArgs = {
                qualMode : "GPIO_QUAL_ASYNC",
            }
            pinmuxQualMod.args.padConfig = "STD";
        }
        submodules = submodules.concat(pinmuxQualMods)
        
        if (inst.useInterrupts && inst.registerInterrupts)
        {
            submodules = submodules.concat([{
                name: "spiRXInt",      
                displayName: "RX Interrupt",
                moduleName: "/driverlib/interrupt.js",
                collapsed: true,
                args: {
                    $name : inst.$name + "_RX_INT",
                    int : "INT_" + inst.$name + "_RX",
                    pinmuxPeripheralModule : "spi",
                    driverlibInt: "INT_#_RX"
                }
            },
            {
                name: "spiTXInt",      
                displayName: "TX Interrupt",
                moduleName: "/driverlib/interrupt.js",
                collapsed: true,
                args: {
                    $name : inst.$name + "_TX_INT",
                    int : "INT_" + inst.$name + "_TX",
                    pinmuxPeripheralModule : "spi",
                    driverlibInt: "INT_#_TX"
                }
            }])
        }

        if (inst.useDMARX)
        {
            submodules = submodules.concat([
                {
                    name: "spiRXDMA",      
                    displayName: "RX DMA",
                    moduleName: "/driverlib/dma.js",
                    collapsed: true,
                    args: {
                        $name : inst.$name + "_RX_DMA",
                    },
                    requiredArgs: {
                        srcAddressLinked: inst.$name + "_RX_DMA_ADDRESS",
                        peripheralRXLinked: true,
                        databusWidthConfig: "DMA_CFG_SIZE_16BIT",
                        triggerSource: "DMA_TRIGGER_LINKED"
                    }
                },
            ])
        }

        if (inst.useDMATX) {
            submodules = submodules.concat([
                {
                    name: "spiTXDMA",
                    displayName: "TX DMA",
                    moduleName: "/driverlib/dma.js",
                    collapsed: true,
                    args: {
                        $name: inst.$name + "_TX_DMA",
                    },
                    requiredArgs: {
                        destAddressLinked: inst.$name + "_TX_DMA_ADDRESS",
                        peripheralTXLinked: true,
                        databusWidthConfig: "DMA_CFG_SIZE_16BIT",
                        triggerSource: "DMA_TRIGGER_LINKED"
                    }
                },
            ])
        }
        return submodules;
    },
    templates: {
        boardc : "/driverlib/spi/spi.board.c.xdt",
        boardh : "/driverlib/spi/spi.board.h.xdt"
    },
    pinmuxRequirements    : Pinmux.spiPinmuxRequirements,
    validate    : onValidate
};


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


exports = spiModule;