// fetch the country factors
def countries = api.findLookupTableValues("CountryFactor")

// store the factors in the api.local space for further re-use
api.local.countries = countries

// transform the countries in a map so we can use it as labels for the drop-down
// and sort the results by the label alphabetically
def labels = countries.collectEntries {
  [it.key1, it.attribute2]
}.sort {
  it.getValue()
}

options = labels.keySet().toList()

// create the user entry
def selectedCountry = api.option("Country", options, labels)

// add input validation and set a default value if the input is not specified
if (!selectedCountry) {
  api.yellowAlert("Country not selected, defaulting to AU")
  api.local.errors << "Country not selected, defaulting to AU"
  selectedCountry = "AU"
}

return selectedCountry

// do this only once during the PL generation
if (api.global.countries == null) {

  // fetch the country factors
  def countries = api.findLookupTableValues("CountryFactor")

  // transform the countries in a map so we can use it as labels for the drop-down
  // and sort the results by the label alphabetically
  def labels = countries.collectEntries {
    [it.key1, it.attribute2]
  }.sort {
    it.getValue()
  }

  def options = labels.keySet().toList()

  // cache the values
  api.global.countries = countries
  api.global.labels = labels
  api.global.options = options
}

return null

// create the user entry
def selectedCountry = api.option("Country", api.global.options, api.global.labels)

// set default value if entry not specified
if (!selectedCountry) {
  api.yellowAlert("Country not selected, defaulting to AU")
  selectedCountry = "AU"
}

return selectedCountry

def sku = api.product("sku")

// get the current or target date
def targetDate = api.calendar().format("yyyy-MM-dd")

// fetch the costs
// we could also do the filter on targetDate here but I couldn't demonstate the usage of a closure later
def data = api.productExtension("Product_Costs")

// find only records where the validity date is lower than the target date
def validRecords = data.findAll{ it.attribute4 <= targetDate }

if (!validRecords) {
  api.redAlert("Cost not found for $sku")
  api.local.errors << "Cost not found for $sku"
  return null
}

// sort the costs by date in descending order and pick the most recent one
validRecords = validRecords.sort { a, b ->
  return b.attribute4 <=> a.attribute4;
}

return validRecords[0].attribute1.toBigDecimal()

def sku = api.product("sku")

// get the current or target date
def targetDate = api.calendar().format("yyyy-MM-dd")

// set up the filters
def filters = [
    Filter.equal("name", "Product_Costs"), // PX name
    Filter.equal("sku", sku), // Sku
    Filter.lessOrEqual("attribute4", targetDate) // Cost Date
]

// fetch the latest cost from the PX
// use the expansion operator to expand a list into a varargs array
def data = api.find("PX", 0, 1, "-attribute4", ["attribute1"], *filters)
if (!data) {
  api.redAlert("Cost not found for $sku")
  api.local.errors << "Cost not found for $sku"
  return 0.0
}

return data[0].attribute1?.toBigDecimal()

// let's create a reference to the library so the code is better readable
// especially useful when there are multiple libraries and/or long names
def Math = libs.DemoLib.MathUtil

def pg = api.product("Product Group")

// fetch the costs from the PX
// notice using the Product Master attribute to filter the PX
def cit = api.stream("PX", null,
    Filter.equal("name", "Product_Costs"),  // PX Name
    Filter.equal("ProductMaster__attribute2", pg)) // Product Group
def costs = cit.collect{ it }
cit.close()

if (!costs) {
  api.local.errors << "Missing costs for group $pg"
  return null
}

def avgCost = costs.sum{ it.attribute1.toBigDecimal() } / costs.size()

return Math.round(avgCost, 4)

// let's create a reference to the library so the code is better readable
// especially useful when there are multiple libraries and/or long names
def Math = libs.DemoLib.MathUtil

// calculate the average costs only once and cache the result
if (api.global.productGroupAverageCosts == null) {

  api.global.productGroupAverageCosts = [:]

  // fetch the distinct product groups (there can be potentially a lot of them)
  def productGroupsIt = api.stream("P", "sku", ["attribute2"], true)
  def productGroups = productGroupsIt.collect { it.attribute2 }
  productGroupsIt.close()

  // remove empty product group
  productGroups -= null

  // for each product group except for empty, calculate the average cost
  for (pg in productGroups) {

    // fetch the costs from the PX
    // notice using the Product Master attribute to filter the PX
    def avgCosts = api.find("PX", 0, 1, "sku", ["attribute1": "AVG"], false,
        Filter.equal("name", "Product_Costs"), // PX Name
        Filter.equal("ProductMaster__attribute2", pg)) // Product Group

    // extract the average cost
    def avgCost = avgCosts ? avgCosts[0].attribute1.toBigDecimal() : null
    if (avgCost == null) {
      api.local.errors << "Missing costs for group $pg"
      continue
    }

    // store the result in the Global cache
    api.global.productGroupAverageCosts[pg] = Math.round(avgCost, 4)

  }
}

// use the cached result on subsequent runs
def productGroup = api.product("Product Group")
return api.global.productGroupAverageCosts[productGroup] ?: null

def pg = api.product("Product Group")

def marginAdj = api.vLookup("MarginAdj", "Margin Adj", pg)
if (marginAdj == null) {
  marginAdj = 0.0
}

return marginAdj

if (api.global.margins == null) {
  // if the key is not found, the map returns 0.0
  api.global.margins = [:].withDefault{ 0.0 }

  def margins = api.findLookupTableValues("MarginAdj")
  margins.inject(api.global.margins, { map, it ->
    map[it.name] = it.attribute1
    return map
  })
}

def pg = api.product("Product Group")
return api.global.margins[pg]