let CONTEXT_CPU1= "CPU1";
let CONTEXT_CPU2= "CPU2";
let CONTEXT_SYSTEM = "system"
let Collateral  = system.getScript("/driverlib/sysconfig_collateral_links.js");

exports = {
    getBoard : getBoard,
    getBoardName : getBoardName,
    getDeviceTRM: getDeviceTRM,
    getDeviceDatasheet: getDeviceDatasheet,
    findDuplicates : findDuplicates,
    peripheralCount: peripheralCount,
    typeMatches: typeMatches,
    peripheralNames: peripheralNames,
    stringOrEmpty: stringOrEmpty,
    removeNonNumber : removeNonNumber,
    gpioNameToNumber : gpioNameToNumber,
    printDebugObject : printDebugObject,
    printDebugObjectKeys : printDebugObjectKeys,
    getGPIOs : getGPIOs,
    getAIOs : getAIOs,
    peripheralListFromSysCtl : peripheralListFromSysCtl,
    getDeviceName: getDeviceName,
    getDevicePart: getDevicePart,
    getDevicePackage: getDevicePackage,
	getSDK: getSDK,
    getC2000WareRelativePath : getC2000WareRelativePath,
	onlyPinmux: onlyPinmux,
	CLB_isType1 : CLB_isType1,
	CLB_isType1_Type2 : CLB_isType1_Type2,
	CLB_isType2 : CLB_isType2,
    autoForce : autoForce,
    autoForceMultiple : autoForceMultiple,
    SYSCLK_getMaxMHz : SYSCLK_getMaxMHz,
	getConfigNameRecursive: getConfigNameRecursive,
    getConfigsRecursive: getConfigsRecursive,
    printConfigsInfo : printConfigsInfo,
    getCollateralFindabilityList : getCollateralFindabilityList,
	zero_to_15        : [
        { name: 0 },
        { 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 },
	],
	zero_to_16        : [
        { name: 0 },
        { 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 },
	],

    CONTEXT_CPU1: CONTEXT_CPU1,
    CONTEXT_CPU2: CONTEXT_CPU2,
    isContextCPU1: isContextCPU1,
    isContextCPU2: isContextCPU2,
    isMultiCoreSysConfig : isMultiCoreSysConfig,
    isMultiCoreDevice : isMultiCoreDevice,
    getModuleForCore : getModuleForCore,
    getContextNames: getContextNames,
    getAllModulesForCore: getAllModulesForCore,
    getModulePaths, getModulePaths,
    getContextDisplayName: getContextDisplayName,
    getOtherContextNames: getOtherContextNames,
    isModuleOnThisContext: isModuleOnThisContext,
    isModuleOnAnyContext: isModuleOnAnyContext,
    isModuleOnOtherContext: isModuleOnOtherContext,
    getModuleForTheFirstAvailableCore : getModuleForTheFirstAvailableCore,
    removeArrayFromArray : removeArrayFromArray,
    getSYSCLK: getSYSCLK,
    getClockTree : getClockTree,
    getC2000WarePath: getC2000WarePath
};

function getSYSCLK(cpu)
{
    var clockTree = getClockTree();
    if (clockTree){

        if (isMultiCoreDevice())
        {
            if (!cpu)
            {
                if (isContextCPU1())
                {
                    cpu = "1"
                    return clockTree["CPU" + cpu + "_SYSCLK"].in
                }
                else
                {
                    cpu = "2"
                    
                    return clockTree["CPU" + cpu + "_SYSCLK"].in
                }
            }
        }
        else
        {
            return clockTree["SYSCLK"].in
        }
    }
    else
    {
        return SYSCLK_getMaxMHz()
    }
}

function getC2000WarePath()
{
    var currnetSDKProductPath = system.getProducts()[0].path
    var sdkPath = system.utils.path.join(currnetSDKProductPath + "../../../")
    sdkPath = sdkPath.replace(new RegExp('\\' + system.utils.path.sep, 'g'), '/')
    if (system.getProducts()[0].name != "C2000WARE")
    {
        sdkPath = sdkPath + "c2000ware/"
    }

    return sdkPath
}

function getC2000WareRelativePath()
{
    if (system.getProducts()[0].name != "C2000WARE")
    {
        return "../../c2000ware"
    }

    return ".."
}

function removeArrayFromArray(arrSource, arrRem)
{
    return arrSource.filter( function( el ) {
      return !arrRem.includes( el );
    } );
}


function getContextDisplayName(cntxName)
{
    return (cntxName == CONTEXT_SYSTEM? CONTEXT_CPU1: cntxName)
}

function isContextCPU1()
{
    if (system.context == CONTEXT_CPU1 || system.context == CONTEXT_SYSTEM)
    {
        return true;
    }
    return false
}

function isContextCPU2()
{
    if (system.context == CONTEXT_CPU2)
    {
        return true;
    }
    return false
}

function getOtherContextNames()
{
    var contextNames = Object.keys(system.contexts)
    return contextNames.filter(e => e !== system.context);
}

function isModuleOnThisContext(moduleName)
{
    return system.modules[moduleName]?true:false;
}

function isModuleOnAnyContext(moduleName)
{
    var cntxs = getContextNames();
    for (var cntx of cntxs){
        if (getModuleForCore(moduleName, cntx)){
            return true;
        }
    }
    return false;
}

function isModuleOnOtherContext(moduleName)
{
    var cntxs = getOtherContextNames();
    for (var cntx of cntxs){
        if (getModuleForCore(moduleName, cntx)){
            return true;
        }
    }
    return false;
}

function getContextNames()
{
    var contextNames = Object.keys(system.contexts)
    return contextNames;
}

//
// Returns true only when the multi-core is laucnhed in sysconfig
// If a multi-core device is launched in signle view it wont return true.
//
function isMultiCoreSysConfig()
{   
    return (getContextNames().length > 1);
}

function isMultiCoreDevice()
{   
    return (system.context.includes("CPU"));
}

function getAllModulesForCore(coreName)
{
    let context = system.contexts[coreName];
    let modules = context ? context.system.modules : {};

    return modules;
}

//
// Handles getting clocktree for multi-core this for multi-core
//
function getClockTree()
{
    var contextNames = getContextNames();
    var mainContext = "system"
    if (contextNames.includes("CPU1"))
    {
        mainContext = "CPU1"
    }
    let context = system.contexts[mainContext];
    let clocktree = context ? context.system.clockTree : null;

    if (system.deviceData.clockTree)
    {
        return clocktree
    }
    else
    {
        return null
    }
}

function getModuleForCore(moduleName, coreName)
{
    let context = system.contexts[coreName];
    let modules = context ? context.system.modules : {};
    let module = modules[moduleName];

    return module;
}

function getModuleForTheFirstAvailableCore(moduleName)
{
    var cntxs = getContextNames();
    for (var cntx of cntxs){
        var mod = getModuleForCore(moduleName, cntx)
        if (mod){
            return mod;
        }
    }
    return null;
}

function getModulePaths(modules)
{
    return Object.keys(modules).sort();;
}

function getBoard()
{
    return system.deviceData.board;
}


function getBoardName()
{
    if (system.deviceData.board)
    {
        return system.deviceData.board.name;
    }
    return null;
}


function getConfigNameRecursive(arrayConfigs)
{
    var configNames = [];
    for (var modConfig of arrayConfigs)
    {        
        if (modConfig.config)
        {
            configNames = configNames.concat(getConfigNameRecursive(modConfig.config))
        }
        else
        {
            var modConfigName = modConfig.name;
            configNames.push(modConfigName);
        }
    }
    return configNames;
}

function getConfigsRecursive(arrayConfigs)
{
    var configNames = [];
    for (var modConfig of arrayConfigs)
    {        
        if (modConfig.config)
        {
            configNames = configNames.concat(getConfigsRecursive(modConfig.config))
        }
        else
        {
            var modConfigName = modConfig;
            configNames.push(modConfigName);
        }
    }
    return configNames;
}

function printConfigsInfo(configByName)
{
    // for (const key in configByName) {
    //     console.log(key);
    //     console.log(configByName[key].name)
    //     console.log(configByName[key].displayName)
    //     console.log(configByName[key].default)
    //     console.log(configByName[key].options)
    // }
    console.log(JSON.stringify(configByName, null, 4));
}


function autoForceMultiple(module_names_paths)
{
    return (function (){
        return module_names_paths
    })

}

function autoForce(module_name, module_path)
{
    return (function (){
        return [{
            name      : module_name,
            moduleName: module_path,
            hidden    : false
        }]
    })

}

function findDuplicates(arrayToCheck)
{
    const count = arrayToCheck =>
      arrayToCheck.reduce((a, b) => ({ ...a,
        [b]: (a[b] || 0) + 1
      }), {})

    const duplicates = dict =>
      Object.keys(dict).filter((a) => dict[a] > 1)

    return {count: count(arrayToCheck), duplicates: duplicates(count(arrayToCheck))};
}

function onlyPinmux()
{
	return false;
}

function getSDK()
{
	var sdk = system.getScript("/.metadata/sdk.json");

    return sdk;
}

function getDeviceName()
{
	var deviceName = system.deviceData.device;
	return deviceName
}

function getDevicePart()
{
    var devicePart = system.deviceData.part;
    return devicePart
}

function getDevicePackage()
{
    var devicePackage = system.deviceData.package;
    return devicePackage
}

function stringOrEmpty(stringToCheck, stringToAdd)
{
    if (stringToCheck != "")
    {
        return stringToAdd;
    }
    return "";
}

function printDebugObject(obj)
{
	if (obj == null)
	{
		console.log("Object is null");
		return;
	}
    var keys = Object.keys(obj);
    for (var key in keys)
	{
    	console.log(keys[key] + " : " + obj[keys[key]]);
    }
}

function printDebugObjectKeys(obj)
{
    if (obj == null)
    {
        console.log("Object is null");
        return;
    }
    var keys = Object.keys(obj);
    console.log("Keys:")
    for (var key in keys)
    {
        console.log(keys[key]);
    }
}

function removeNonNumber(stringToCheck)
{
	var numberOnly = "";
    if (stringToCheck != "")
    {
    	for (var i = 0; i < stringToCheck.length; i++)
    	{
    		if ("0123456789".includes(stringToCheck[i]))
    		{
    			numberOnly += stringToCheck[i];
    		}
    	}
        return numberOnly;
    }
    return "";
}

//As soon a number is detected and then more characters are detected, exit.
//Good for usecases like GPIO180_X2, the 2 is not added to the numbers
function gpioNameToNumber(stringToCheck)
{
	var numberOnly = "";
	var numbersDetected = false;
    if (stringToCheck != "")
    {
    	for (var i = 0; i < stringToCheck.length; i++)
    	{
    		if ("0123456789".includes(stringToCheck[i]))
    		{
    			numberOnly += stringToCheck[i];
    			numbersDetected = true;
    		}
    		else
    		{
    			if (numbersDetected)
        		{
        			return numberOnly;
        		}
    		}
    	}
        return numberOnly;
    }
    return "";
}

function getGPIOs()
{
	var allGpioNames = [];
	let gpio = system.deviceData.interfaces.GPIO;
	if (gpio != null)
	{
		for (var i = 0; i < gpio.peripherals.length; i++)
		{
			var gpioperiph = gpio.peripherals[i];
			allGpioNames.push(gpioperiph.name);
		}
	}
	return allGpioNames
}

function getAIOs()
{
	var allAioNames = [];
	let aio = system.deviceData.interfaces.AIO;
	if (aio != null)
	{
		for (var i = 0; i < aio.peripherals.length; i++)
		{
			var aioperiph = aio.peripherals[i];
			allAioNames.push(aioperiph.name);
		}
	}
	return allAioNames;
}

function peripheralListFromSysCtl(peripheralName, sysctl)
{
    var peripherals = []
    sysctl.SysCtl_PeripheralPCLOCKCR.forEach((element, index) => {
        var split_by_underscore = element.name.split("_")
        var peripheralInst = split_by_underscore[split_by_underscore.length - 1];
        if (peripheralInst.startsWith(peripheralName))
        {
            peripherals.push(peripheralInst)
        }
    });
    return peripherals
}

function peripheralCount(peripheralType)
{
	let peripherals = system.deviceData.peripherals
	let numberOfPeripherals = Object.keys(peripherals).length;
	var count = 0;

	//console.log(numberOfPeripherals);

	for (var peripheral in peripherals) {

	  	try
	  	{
	  		var interfaces = peripherals[peripheral]["interfaces"];
	  		for (var interfaceType in interfaces)
	  		{
	  			if (peripheralType == interfaceType)
	  			{
	  				peripheralNames = interfaces[interfaceType].peripherals;
	  				//console.log(peripheralNames);
	  				count = peripheralNames.length;
					//console.log(count);
	  				return count;
	  			}
			}
		}
		catch(err) {

		}
	}
	if (count == 0)
	{
		return -1;
	}
    return (count);
}


function peripheralNames(peripheralType)
{
	let peripherals = system.deviceData.peripherals
    //console.log(peripherals);
	let numberOfPeripherals = Object.keys(peripherals).length;
	var names = [];

	//console.log(numberOfPeripherals);

	for (var peripheral in peripherals) {

	  	try
	  	{
	  		var interfaces = peripherals[peripheral]["interfaces"];
            //console.log(interfaces);
	  		for (var interfaceType in interfaces)
	  		{
	  			if (peripheralType == interfaceType)
	  			{
	  				names = interfaces[interfaceType].peripherals;
	  				//console.log(names);
	  				return names;
	  			}
			}
		}
		catch(err) {

		}
	}
    //console.log(names);
    return (names);
}


function CLB_isType1() {
    return ["F28004x"].includes(getDeviceName());
}

function CLB_isType2() {
    return ["F28002x", "F2838x", "F28003x", "F28P55x", "F28P65x"].includes(getDeviceName());
}

function CLB_isType1_Type2(){
    return (CLB_isType1() | CLB_isType2());
}

function SYSCLK_getMaxMHz()
{
    var sysclk_max = {
        F2807x      : 120,
        F2837xS     : 200,
        F2837xD     : 200,
        F2838x      : 200,
        F28004x     : 100,
        F28002x     : 100,
        F28003x     : 120,
        F280013x    : 120,
        F280015x    : 120,
        F28P65x     : 200,
        F28P55x     : 150
    }
    return sysclk_max[getDeviceName()];
}



/*
 *  ======== typeMatches ========
 *  Check that HW signal type matches a specified array of types
 *
 *  Example: within a module's filterHardware(component) method:
 *      for (sig in component.signals) {
 *          let type = component.signals[sig].type;
 *          if (Common.typeMatches(type, ["PWM", "DOUT"])) {
 *              :
 *          }
 *      }
 *
 *  type      - a string or array of strings that are valid signal types
 *  nameArray - array of signal name types that must match one of the signal
 *              types named by type
 *
 *  Returns true iff nameArray contains at least one type name that's
 *          specified the type parameter.
 */
function typeMatches(type, nameArray)
{
    let options = {};

    if (type instanceof Array || typeof type == "object") {
        for (var i = 0; i < type.length; i++) {
            options[type[i]] = 1;
        }
    }
    else if (typeof type == "string" || type instanceof String) {
        options[type] = 1;
    }

    for (var i = 0; i < nameArray.length; i++) {
        let name = nameArray[i];
        if (name in options) {
            return (true);
        }
    }

    return (false);
}

function getDeviceTRM()
{
    var deviceTRMLinks = {
        "F2807x":   "https://www.ti.com/lit/spruhm9",
        "F2837xS":  "https://www.ti.com/lit/spruhx5",
        "F2837xD":  "https://www.ti.com/lit/spruhm8",
        "F28004x":  "https://www.ti.com/lit/sprui33",
        "F2838x":   "https://www.ti.com/lit/spruii0",
        "F28002x":  "https://www.ti.com/lit/spruin7",
        "F28003x":  "https://www.ti.com/lit/spruiw9",
        "F280013x": "https://www.ti.com/lit/spruix1",
        "F280015x": "https://www.ti.com/lit/spruiy4",
		"F28P65x":  "https://www.ti.com/lit/spruiz1"
    }

    var deviceTRMLink = deviceTRMLinks[getDeviceName()];
    if (deviceTRMLink)
    {
        return deviceTRMLink
    }
    else
    {
        return ""
    }
}

function getDeviceDatasheet()
{
    var deviceDSLinks = {
        "F2807x":   "https://www.ti.com/lit/gpn/tms320f28075",
        "F2837xS":  "https://www.ti.com/lit/gpn/tms320f28377s",
        "F2837xD":  "https://www.ti.com/lit/gpn/tms320f28379d",
        "F28004x":  "https://www.ti.com/lit/gpn/tms320f280049",
        "F2838x":   "https://www.ti.com/lit/gpn/tms320f28388d",
        "F28002x":  "https://www.ti.com/lit/gpn/tms320f280025c",
        "F28003x":  "https://www.ti.com/lit/gpn/tms320f280039c",
        "F280013x": "https://www.ti.com/lit/gpn/tms320f2800137",
        "F280015x": "https://www.ti.com/lit/gpn/tms320f2800157",
		"F28P65x":  "https://www.ti.com/lit/gpn/tms320f28p650dk"
    }

    var deviceDSLink = deviceDSLinks[getDeviceName()];
    if (deviceDSLink)
    {
        return deviceDSLink
    }
    else
    {
        return ""
    }
}

function getCollateralFindabilityList(peripheral)
{
    var res = "";
    //*********************************************************************
    // GETTING STARTED WITH SYSCONFIG
    //*********************************************************************
    res += "**"
    res += "Sysconfig Resources"
    res += "**\n"
    res += "*   [C2000 SysConfig - Step by Step Guide on How to use C2000 SysConfig](https://www.ti.com/lit/spracx3)\n"
    res += "*   [C2000 SysConfig - Speed Up Development With C2000 Real-Time MCUs Using SysConfig](https://www.ti.com/lit/spry341)\n"
    res += "\n"

    var deviceGPN = getDeviceName();
    var cdata = Collateral.getCollateralData();
    // console.log(cdata[peripheral]);
    for (var i=0; i < cdata[peripheral].length; i++)
    {
        //*********************************************************************
        // CATEGORY TITLE
        //*********************************************************************
        var category_dict = cdata[peripheral][i];
        // console.log(category_dict['category_displayName'])

        // first check if the category is used by this device at all (not filtered out from this device)
        var category_used = false;
        for (var j=0; j < category_dict['content'].length; j++)
        {
            var content_dict = category_dict['content'][j]
            if (    ('devices' in content_dict && content_dict['devices'].includes(deviceGPN)) ||
                    !('devices' in content_dict)
            )
            {
                category_used = true;

                // break out of loop on the first occurrence of a collateral that is used for this device
                break;
            }
        }

        // now if it was used, go ahead and add the category title
        if (category_used)
        {
            res += "\n# **" +
                    category_dict['category_displayName'] +
                    "**\n"
        }

        //*********************************************************************
        // COLLATERAL LINKS WITHIN CATEGORY
        //*********************************************************************
        // add each content item that applies
        for (var j=0; j < category_dict['content'].length; j++)
        {
            var content_dict = category_dict['content'][j]
            if (    ('devices' in content_dict && content_dict['devices'].includes(deviceGPN)) ||
                    !('devices' in content_dict)
            )
            {
                // italicize if this is an App Note
                if ( 'appNote' in content_dict )
                {
                    res += "*   *[" +
                            content_dict['name'] +
                            "](" +
                            content_dict['url'] +
                            ")*"
                }
                // don't italicize if not an app note
                else
                {
                    res += "*   [" +
                            content_dict['name'] +
                            "](" +
                            content_dict['url'] +
                            ")"
                }

                // add a (Video) tag if this is a video
                if ('video' in content_dict)
                {
                    res += " (Video)"
                }

                // now add a newline to finish up the normal bullet
                res += "\n"

                //*********************************************************************
                // EXTRA TEXT FOR THIS COLLATERAL LINK
                //*********************************************************************
                // add the "Extra Text" as a sub-bullet if it exits
                if ('description' in content_dict)
                {
                    res += "    *   " +
                            content_dict['description'] +
                            "\n"
                }
            }
        }

    }

    //*********************************************************************
    // DEVICE TRM
    //*********************************************************************
    // finally, add the device TRM to the bottom of the list
    // res += "---\n"
    res += "\n# ***"
    res += "["+deviceGPN+" Technical Reference Manual](" + getDeviceTRM() + ")"
    res += "***\n"


    return res
}