{
  "name": "default",
  "tabs": [
    {
      "name": "header",
      "translationKey": "sfdc_quotes_tabs_header",
      "type": "header"
    },
    {
      "name": "Product Configurator",
      "translationKey": "Product Configurator",
      "typeReference": "eCFO_ProductConfigurator",
      "type": "customForms"
    },
    {
      "name": "items",
      "parameters": {
        "defaultPlacement": "right",
        "flexibleLayout": true
      },
      "translationKey": "sfdc_quotes_tabs_items",
      "type": "items"
    },
    {
      "name": "attachments",
      "translationKey": "sfdc_quotes_tabs_attachments",
      "type": "attachments"
    },
    {
      "name": "workflow",
      "translationKey": "sfdc_quotes_tabs_workflow",
      "type": "workflow"
    },
    {
      "name": "workflow-history",
      "translationKey": "sfdc_quotes_tabs_workflowHistory",
      "type": "workflowHistory"
    },
    {
      "name": "messages",
      "translationKey": "sfdc_entity_tabs_messages",
      "type": "header"
    }
  ]
}

api.inputBuilderFactory()
            .createInputMatrix("LocksAndHandlesMatrix")
            .setLabel("Locks and Handles Configurator Table")
            .setHideAddButton(true)
            .setHideRemoveButton(false)
            .setColumnValueOptions(['Colour': colors, 'Material': materials])
            .setColumns(['Product Id', 'Label', 'Base Price', 'Material', 'Colour'])
            .setReadOnlyColumns(['Product Id', 'Label', 'Base Price'])
            .addOrUpdateInput(customFormProcessor, 'ROOT')

api.findLookupTableValues('ColorAdjustment')['name']

api.inputBuilderFactory()
        .createProductGroupEntry('productDoorframes')
        .setLabel("Doorframes")
        .setFilterFormulaName("eCFO_ProductFilter")
        .setFilterFormulaParam("Doorframes")
        .addOrUpdateInput(customFormProcessor, 'ROOT')

def addProduct(def product) {
    def label = product["Label"]
    def sku = product["Product Id"]

    def updateProductMap = [
            "sku"       : sku,
            "label"     : label,
            "attribute1": "DoorSet",
            "unitOfMeasure": "EA",
            "currency": "EUR",
            "attribute2": "BU-DoorSet",
            "attribute3": "UNDEFINED",
            "attribute4": "default",
            "attribute5": "default",
            "attribute6": "Introduction",
    ]

    api.add("P", updateProductMap)
}

/**
 * Adds a new product's base value via an API call.
 *
 * @param product The product whose base value is to be added. This should
 *                be a map containing at least a "Label", a "Product Id"
 *                and a "Base Price".
 *                Example: 
 *                ['Label': 'Doorframes-DR-0013-1981 x 686-Wood-yellow/Locks&handles-DR-0029-Wood-gray', 
 *                 'Product Id': 'DOORSET-y0QNSxCuYj', 
 *                 'Base Price': '99.99']
 */
def addProductBaseValue(def product) {
    def label = product["Label"]
    def sku = product["Product Id"]
    def basePrice = product["Base Price"]

    def updateValueMap = [
            "name"      : "ProductBaseValues",
            "sku"       : sku,
            "attribute1": label,
            "attribute2": basePrice
    ]

    api.add("PX3", updateValueMap)
}

//Output.groovy methods
/**
 * This method is used to create a label configuration based on the provided parameters.
 *
 * @param label     The initial label.
 * @param doorSize  The size of the door. If it's available, it will be appended to the label after a dash.
 * @param material  The material of the door. If it's not empty/null, it will be appended to the label after a dash.
 * @param colour    The colour of the door. If defined, it will be appended to the label after a dash.
 * @return          A String that represents the new label. If the original label starts with 'Basic-',
 *                  it is replaced. Dash-separated size, material, and colour are appended if available.
 */
def labelConfigurator(def label, def doorSize, def material, def colour) {
    //Your code: check the requirements for calculation result table
}

/**
 * Calculates the price of a door based on various parameters.
 *
 * @param basePrice  The base price of the door. It must be a valid number.
 * @param doorSize   The size of the door. If not provided, it defaults to "default".
 * @param material   The material of the door. If not provided, it defaults to "default".
 * @param colour     The colour of the door. If not provided, it defaults to "default".
 *
 * @return Returns the total price as a BigDecimal.
 *         The price is calculated as the base price multiplied by the total increase percent which includes the material,
 *         color and door size price increments.
 */
def calculateDoorPrice(basePrice, doorSize, material, colour) {
    //Your code: check the requirements for calculation result table
}

/**
 * This function generates a new product Id in a specific format.
 * The format is "DOORSET-" followed by a UUID of length 10 characters.
 * The UUID is generated using an external API.
 *
 * @return A New formatted Product ID string
 */
def generateNewProductId(def productId) {
      //Your code: check the requirements for calculation result table
}

// SaveData.groovy methods
/**
 * This method creates information messages about products and their base values.
 * Then, it uses this data to set an alert message through the `api`.
 *
 * @param addedProducts  - A list of products represented as Maps where each Map should contain a "LABEL" key. The values of "LABEL" are used to construct a part of the information message.
 * @param addedBaseValue - A list of product base values represented as Maps where each Map should contain "LABEL" and "BASE_PRICE" keys. The values of these keys are used to construct a part of the information message.
 *
 * Note: Any changes or operations executed inside this method does not affect original list of maps passed as `addedProducts` and `addedBaseValue`.
 */
def addInfoMessage(addedProducts, addedBaseValue) {
    addedProducts  = addedProducts.collect({
        it[LABEL]
    }).join("<br>")

    addedBaseValue  = addedBaseValue.collect({
        it[LABEL]+", Base Price: "+it[BASE_PRICE]
    }).join("<br>")

    String productInfo = "<br>Following products has been added to Product Table: <br>$addedProducts <br>"
    String valuesInfo = "<br>Following products has been added to Product Base Values Table: <br>$addedBaseValue<br>"
    String info = ""

    if (!addedBaseValue.isEmpty()) {
        info += valuesInfo
    }

    if (!addedProducts.isEmpty()) {
        info += productInfo
    }

    api.setAlertMessage(info)
}

// 1. If the form being processed is in the post phase, 
//    immediately return and skip the rest of the code.

// 2. Add a product group entry for doorframes, 
//    filtered by 'Doorframes' to the form.

// 3. Add a product group entry for locks and handles, 
//    filtered by 'Locks&handles' to the form.

// 4. Get the names from the 'Material', 
//    'Color' and 'DoorSizes' look-up tables.

// 5. Create configurator tables for doorframes and locks/handles.

// 6. Get Products data from "productDoorframes" and "productLocksAndHandles"

// 7. If there are any Doorframes products, populate 
//    the DoorframesMatrix of the form with relevant data. 
//    Otherwise, set the matrix to empty.

// 8. If there are any LocksAndHandles products, populate 
///   the LocksAndHandlesMatrix of the form with relevant data. 
//    Otherwise, set the matrix to empty.

// 9. Create a boolean entry in the form processor to hold 
//    the state of whether changes should be saved.

// 1. If the form processor is in pre-phase, 
//    exit from the function

// 2. Get the current item from the API

// 3.Find the 'LocksAndHandlesMatrix' values 
//   from the currentItem's inputs. 
//   Assign these values to the LocksAndHandles collection.

// 4.Find the 'DoorframesMatrix' values from the currentItem's inputs.
//   Assign these values to the doorframes collection.

// 5. Use nested loops to add new door product to the newDoors collection    
def newDoors = []
// Iterate over the doorframes collection.
doorframes.each { doorframe ->
    // Configure and assign a label to the doorframe item by using its properties.
    // Calculate price for the doorframe item by using its properties.
    // Use calculateDoorPrice and labelConfigurator methods

    // Iterate over the lockAndHandles collection.
    lockAndHandles.each {
        // Configure and assign a label to the lockAndHandle item by using its properties.
        // Calculate price for the lockAndHandle item by using its properties.      
        // Use calculateDoorPrice and labelConfigurator methods
        
        // Concatenate doorframeLabel and lockHandleLabel separated by a slash.(newLabel)
        // Calculate the total price by adding doorframePrice and lockHandlePrice.(newPrice)
    
        // Create a row for the new door product with its ID, label, and base price.
        def singleRow = [
                'Product Id': Utils.generateNewProductId(),
                'Label'     : newLabel,
                'Base Price': newPrice
        ]

        // Add the new door product to the newDoors collection.
        newDoors.add(singleRow)
    }
}

// 6. Generate a new matrix for the new products

// 7. Add the generated newDoors to de newProducts matrix

// 8. Add or update the output of the processed form by 
//    establishing a new "discountMatrix" result

// 9. return the generated rows

// 1. If the customFormProcessor is in the pre-phase, 
//    end the function immediately

// 2. get the current item from the api

// 3. find 'saveChangesBoolean' from currentItem's inputs, 
//    which determines whether changes should be saved
      
// 4. If changes need to be saved, proceed
if (save) {
    // 5. get the output from the out.Output
  
    // 7. create empty lists for addedBaseValue 
    //    and addedProducts
    
    // 8. for each product in output
    output.each { product ->
        // check if the product exists in Product Master table
        // check if product base value exists in Product Extensions table
          
        // if the product does not exist in Product Master table
        // a) add the product
        // b) add the product to the list of added products
          
        // if product base value does not exist in Product Extensions table
        // a) add product base value
        // b) add the product to the list of added base value
    }
    
    // add information message about the added products and base values
    Utils.addInfoMessage(addedProducts, addedBaseValue)
}