/**
 * Logic:
 * 1. Queries a sample of maximum 50 entities.
 * 2. Calculates the average of the `device.powersupply.battery.charge` values.
 * 3. Update "VentanaPrincipal" value with the average.
 * 4. If the floor of average is even, changes "VentanaPrincipal" status to Red (#FF0000).
 * 5. If the floor of average is odd, changes "VentanaPrincipal" status to Green (#00FF00).
 */

// 1. Create the builder to search for entities, limiting to 50
var builder = $api.entitiesSearchBuilder()
    .limit(50)
    .flattened();

// 2. Execute the query
var response = await builder.build().execute();

var totalCharge = 0;
var count = 0;

// 3. Iterate through the results and sum the battery charge
if (response && response.data && response.data.entities) {
    response.data.entities.forEach(function(entity) {
        // Access the battery charge field
        // Field: device.powersupply.battery.charge
        var batteryField = entity['device.powersupply.battery.charge'];
        
        if (batteryField && batteryField._value && batteryField._value._current && batteryField._value._current.value) {
            var val = parseFloat(batteryField._value._current.value);
            if (!isNaN(val)) {
                totalCharge += val;
                count++;
            }
        }
    });
}

// 4. Calculate Average
var average = count > 0 ? totalCharge / count : 0;

// 5. Determine color based on parity of the floor of the average
// Even -> Red "#FF0000"
// Odd -> Green "#00FF00"
var floorAvg = Math.floor(average);
var isEven = floorAvg % 2 === 0;
var color = isEven ? "#FF0000" : "#00FF00";

// 6. Set the item status and value
// setItemStatus(itemID, [rgbColor(string format)|null])
setItemStatus("VentanaPrincipal", color);

// setValueToItem(itemID, alias, value)
setValueToItem("VentanaPrincipal", "Battery Avg", average.toFixed(2));

// Use return as the function is async
return;

/**
 * Logic:
 * 1. Iterates through ALL entities in the platform using `executeWithAsyncPaging` (efficient pagination).
 * 2. Calculates the average of the `device.powersupply.battery.charge` values across all entities.
 * 3. Update "VentanaPrincipal" value with the global average.
 * 4. If the floor of average is even, changes "VentanaPrincipal" status to Red (#FF0000).
 * 5. If the floor of average is odd, changes "VentanaPrincipal" status to Green (#00FF00).
 */

var totalCharge = 0;
var count = 0;

// 1. Create the builder
var builder = $api.entitiesSearchBuilder()
    .limit(2000) // Max limit per page
    .flattened();

// 2. Execute with async paging
// executeWithAsyncPaging(resourceName) returns a Promise
return builder.build().executeWithAsyncPaging('entities').then(
    // Success Callback (called when all pages are processed)
    function() {
        // 4. Calculate Average
        var average = count > 0 ? totalCharge / count : 0;

        // 5. Determine color based on parity of the floor of the average
        var floorAvg = Math.floor(average);
        var isEven = floorAvg % 2 === 0;
        var color = isEven ? "#FF0000" : "#00FF00";

        // 6. Set the item status and value
        setItemStatus("VentanaPrincipal", color);
        setValueToItem("VentanaPrincipal", "Battery Avg", average.toFixed(2));
    },
    // Error Callback
    function(err) {
        console.error("Error in paging:", err);
    },
    // Notify Callback (called for each page of results)
    function(pageData) {
        if (pageData && pageData.length > 0) {
            pageData.forEach(function(entity) {
                // Access the battery charge field
                var batteryField = entity['device.powersupply.battery.charge'];
                
                if (batteryField && batteryField._value && batteryField._value._current && batteryField._value._current.value) {
                    var val = parseFloat(batteryField._value._current.value);
                    if (!isNaN(val)) {
                        totalCharge += val;
                        count++;
                    }
                }
            });
        }
    }
);

// Check if a value is provided
if (!value) {
  console.warn("No value provided for search.");
  return;
}

// Define the API endpoint (JSONPlaceholder)
// We'll filter todos by userId based on the input value
var apiUrl = "https://jsonplaceholder.typicode.com/todos?userId=" + value;

console.log("Fetching data from: " + apiUrl);

try {
  // Perform the request using the platform's http utility (encapsulation of Nuxt 4 useFetch)
  // useFetch typically parses JSON automatically.
  // We await the result. 
  // Note: useFetch in Nuxt returns { data, error, ... }
  const { data, error } = await http(apiUrl);

  if (error && error.value) {
    throw new Error("Generic Error: " + error.value);
  }

  // Access the data (Ref value if it's a ref, or direct if the utility un-refs it)
  // Assuming standard Nuxt composition API behavior where top level properties are Refs
  const results = data.value || data;

  console.log("--- Search Results (User ID: " + value + ") ---");
  // Check if we got any results
  if (results && results.length > 0) {
    console.table(results); // Display as a table for better readability
    console.log("Total records found: " + results.length);
  } else {
    console.log("No records found for User ID: " + value);
  }

} catch (err) {
  console.error("Fetch error:", err);
}

// Check if model is provided
if (!model) {
  console.warn("No form data (model) provided.");
  return;
}

const { name, specificType } = model;
console.log("Searching entities with Name:", name, "and Specific Type:", specificType);

// Create the builder
var builder = $api.entitiesSearchBuilder().flattened();

// Define filters based on model values
var filter = {
  and: [
    {
      eq: {
        'resourceType': 'entity.device'
      }
    }
  ]
};

if (name) {
  filter.and.push({
    like: {
      'provision.administration.identifier': name // Assuming 'name' maps to identifier for this example, or use 'provision.device.name' if appropriate
    }
  });
}

if (specificType) {
  filter.and.push({
    eq: {
      'provision.device.specificType': specificType
    }
  });
}

// Apply filter if any conditions were added
if (filter.and.length > 0) {
  builder.filter(filter);
}

try {
  // Execute the search
  // await is supported in this context
  const response = await builder.build().execute();

  if (response.statusCode === 200) {
    console.log("--- Entity Search Results ---");
    const entities = response.data.entities;
    if (entities && entities.length > 0) {
      console.table(entities.map(e => ({
        id: e['provision.administration.identifier']._value._current.value,
        specificType: e['provision.device.specificType'] ? e['provision.device.specificType']._value._current.value : 'N/A'
      })));
      console.log("Total entities found:", entities.length);
    } else {
      console.log("No entities match the criteria.");
    }
  } else {
    console.error("Search failed with status:", response.statusCode);
  }

} catch (err) {
  console.error("Error executing entity search:", err);
}

return {
  title: {
    text: 'Referer of a Website',
    subtext: 'Fake Data',
    left: 'center'
  },
  tooltip: {
    trigger: 'item'
  },
  legend: {
    orient: 'vertical',
    left: 'left'
  },
  series: [
    {
      name: 'Access From',
      type: 'pie',
      radius: '50%',
      data: [
        { value: 1048, name: 'Search Engine' },
        { value: 735, name: 'Direct' },
        { value: 580, name: 'Email' },
        { value: 484, name: 'Union Ads' },
        { value: 300, name: 'Video Ads' }
      ],
      emphasis: {
        itemStyle: {
          shadowBlur: 10,
          shadowOffsetX: 0,
          shadowColor: 'rgba(0, 0, 0, 0.5)'
        }
      }
    }
  ]
};

const getDaysArray = function (start, end) {
  const arr = [];
  var curMonth;
  var monthData = {};
  var days = [];
  for (const dt = new Date(start); dt <= new Date(end); dt.setDate(dt.getDate() + 1)) {
    var curDate = new Date(dt);

    var newMonth = (curDate.getMonth() + 1) + '/' + curDate.getFullYear();

    if (curMonth && curMonth !== newMonth) {
      monthData = {
        value: curMonth,
        children: days
      };
      arr.push(monthData);
      days = [];
    }

    days.push(curDate.getDate() + '/' + (curDate.getMonth() + 1) + '/' + curDate.getFullYear());


    curMonth = newMonth;
  }

  if (days.length) {
    monthData = {
      value: curMonth,
      children: days
    };
    arr.push(monthData);
  }
  return arr;
};

const chartConfig = {
  visualMap: {
    type: 'continuous',
    min: 0,
    max: 1,
    dimension: 2,
    calculable: true,
    orient: 'horizontal',
    top: 5,
    left: 'center',
    color: ['#0f0', '#f00']
  },
  legend: {
    show: true,
    bottom: 10
  },
  matrix: {
    x: {
      data: [],
      levelSize: 40,
    },
    y: {
      label: {
        show: true,
        width: 150
      },
      levelSize: 150,
      data: []
    },
    top: 70,
    bottom: 40,
    left: 2,
    right: 2
  },
  series: {
    type: 'heatmap',
    coordinateSystem: 'matrix',
    data: [],
    label: {
      show: false
    }
  },
  tooltip: {
    show: true
  }
};

// busqueda de todas las entidades
var entitiesBuilder = $api.entitiesSearchBuilder().limit(1000, 1);
var entitiesFilter = {
  and: [{
    eq: {
      'provision.device.specificType': 'METER'
    }
  }]
};
if (filters && filters.generic) {
  entitiesFilter.and.push({
    eq: {
      'provision.administration.identifier': filters.generic
    }
  });
}

entitiesBuilder.filter(entitiesFilter);

const tempData = {};

var initDate = new Date(new Date().getDate() - 30);
var endDate = new Date();

var filter = {
  and: [{
    eq: {
      "datapoints.datastreamId": "volTot"
    }
  }]
};


if (filters && filters.period) {
  if (filters.period.from) {
    initDate = new Date(filters.period.from);
    filter.and.push({
      gte: {
        'datapoints._current.at': filters.period.from
      }
    });
  }

  if (filters.period.to) {
    endDate = new Date(filters.period.to);
    filter.and.push({
      lt: {
        'datapoints._current.at': filters.period.to
      }
    });
  }
}

chartConfig.matrix.x.data = getDaysArray(initDate, endDate);

var response = await entitiesBuilder.flattened().build().execute();

if (response && response.data && response.data.entities && response.data.entities.length > 0) {
  response.data.entities.forEach((entityDataTmp) => {
    const entityIdentifier = entityDataTmp['provision.administration.identifier']._value._current.value;

    if (!tempData[entityIdentifier]) {
      tempData[entityIdentifier] = [];

      chartConfig.matrix.x.data.forEach((monthData) => {
        monthData.children.forEach((dayData) => {
          tempData[entityIdentifier].push([dayData, entityIdentifier, 0]);
        });
      });
    }
  });
}


var builder = $api.datapointsSearchBuilder().limit(2000, 1).addSortBy('datapoints._current.at', 'DESCENDING');


builder.filter(filter).build().executeWithAsyncPaging('datapoints').then(
  function endFunction() {
    //drawChart(datapointsBuffer, true)
    chartConfig.matrix.y.data = Object.keys(tempData);

    let finalData = [];
    chartConfig.matrix.y.data.forEach((deviceId) => {
      finalData = finalData.concat(tempData[deviceId]);
    });
    chartConfig.series.data = finalData;
    callback(chartConfig);
  },
  function cancelado(err) {
    console.error(err);
    //drawChart(datapointsBuffer, true)
    callback(chartConfig);
  },
  function notify(notifyData) {
    if (notifyData && notifyData.length > 0) {
      notifyData.forEach((datapoint) => {
        if (!tempData[datapoint.entityIdentifier]) {
          tempData[datapoint.entityIdentifier] = [];

          chartConfig.matrix.x.data.forEach((monthData) => {
            monthData.children.forEach((dayData) => {
              tempData[datapoint.entityIdentifier].push([dayData, datapoint.entityIdentifier, 0]);
            });
          });
        }

        const currentAt = new Date(datapoint._current.at);
        const currentAtTxt = currentAt.getDate() + '/' + (currentAt.getMonth() + 1) + '/' + currentAt.getFullYear();
        const atIndex = tempData[datapoint.entityIdentifier].findIndex((element) => element[0] === currentAtTxt);
        tempData[datapoint.entityIdentifier][atIndex][2] = 1;
      });
    }
  }
).catch(function (err) {
  console.error(err);
});

function baState(value) {
  if (value) {
    var newValor;
    var style;
    var title;
    switch (value) {
      case "0":
        newValor = "(OK)🟢";
        style = 'color:green;';
        title = "Bateria OK";
        break;
      case "1":
        newValor = "(BAJA)🟡";
        style = 'color:yellow;';
        title = "Bateria BAJA";
        break;
      case "2":
        newValor = "(MUY BAJA)🟠";
        style = 'color:orange;';
        title = "Bateria MUY BAJA";
        break;
      case "3":
        newValor = "(AGOTADA)🔴";
        style = 'color:red;';
        title = "Bateria AGOTADA";
        break;
      default:
        newValor = "Error en el campo";
        break;
    }
    return {
      _style: style,
      value: "<div title='" + title + ">" + newValor + "</div>"
    };
  } else {
    return 'N/A';
  }
}

function bpaState(value) {
  var newValor;
  var title;
  var style;
  if (value) {
    switch (value) {
      case "0":
        newValor = "(OK)🟢";
        title = "Protección no activa";
        style = 'color:green;';
        break;
      case "1":
        newValor = "(ACTIVADA)🔴";
        title = "Protección activada";
        style = 'color:red;';

        break;
      default:
        newValor = "Error en el campo";
        break;
    }
    return {
      value: "<div title='" + title + "'>" + newValor + "</div>",
      _style: style
    };
  }
}

function boolState(value) {
  var newValor;
  var title;
  var style;
  if (value === true || value === false) {
    if (value) {
      newValor = "🔴";
      title = "TRUE";
      style = 'color:red;';
    } else {
      newValor = "🟢";
      title = "FALSE";
      style = 'color:green;';
    }
    return {
      value: "<div title='" + title + "'>" + newValor + "</div>",
      _style: style
    };
  }
}


console.log("--------------------------------------------");
var builder = $api.entitiesSearchBuilder().limit(1000).flattened();

var filter = {
  and: [
    {
      neq: {
        'provision.device.specificType': 'CONCENTRATOR'
      }
    }
  ]
};

if (entityData && entityData['provision.administration.identifier']) {
  var entityKey = entityData['provision.administration.identifier']._value._current.value;
  filter.and.push({
    eq: {
      'provision.Sector': entityKey
    }
  });
}

builder.filter(filter);

const response = await builder.build().execute();

var entities = [];
if (response.statusCode === 200) {
  response.data.entities.forEach(function (entityTmp) {
    var finalData;
    if (entityTmp['ba']) {
      finalData = {
        identifier: {
          value: entityTmp['provision.administration.identifier']._value._current.value,
          _style: 'margin-left: 4px;'
        }
      };
      finalData.tipo_alerta = 'Batería';
      finalData.estado = baState(entityTmp['ba']._value._current.value);
      finalData.fecha = new Date(entityTmp['ba']._value._current.at).toLocaleString();
      entities.push(finalData);
    }

    if (entityTmp['bpA']) {
      finalData = {
        identifier: {
          value: entityTmp['provision.administration.identifier']._value._current.value,
          _style: 'margin-left: 4px;'
        }
      };
      finalData.tipo_alerta = 'Protección Batería';
      finalData.estado = bpaState(entityTmp['bpA']._value._current.value);
      finalData.fecha =  new Date(entityTmp['bpA']._value._current.at).toLocaleString();
      entities.push(finalData);
    }

    if (entityTmp['ta']) {
      finalData = {
        identifier: {
          value: entityTmp['provision.administration.identifier']._value._current.value,
          _style: 'margin-left: 4px;'
        }
      };
      finalData.tipo_alerta = 'Tampering';
      finalData.estado = boolState(entityTmp['ta']._value._current.value);
      finalData.fecha = new Date( entityTmp['ta']._value._current.at).toLocaleString();
      entities.push(finalData);
    }

    if (entityTmp['fa']) {
      finalData = {
        identifier: {
          value: entityTmp['provision.administration.identifier']._value._current.value,
          _style: 'margin-left: 4px;'
        }
      };
      finalData.tipo_alerta = 'Fuga';
      finalData.estado = boolState(entityTmp['fa']._value._current.value);
      finalData.fecha =  new Date(entityTmp['fa']._value._current.at).toLocaleString();
      entities.push(finalData);
    }

  });
}

return entities;

// Main function executed by the Custom Table widget
// parameters: entityData, filters, page, pageElements, callback

// Base URL for USGS Earthquake API (GeoJSON format)
let url = 'https://earthquake.usgs.gov/fdsnws/event/1/query?format=geojson&limit=200';

// 1. Handle Date Filters (Server-Side)
if (filters && filters.period && filters.period.from && filters.period.to) {
  // Helper to format date as YYYY-MM-DD
  const formatDate = (dateStr) => new Date(dateStr).toISOString().split('T')[0];
  
  const start = formatDate(filters.period.from);
  const end = formatDate(filters.period.to);
  
  url += `&starttime=${start}&endtime=${end}`;
} else {
  // Default to 'now' if no filter (API defaults to last 30 days usually, let's limit to recent)
  // Actually, let's explicitely ask for last 2 days to keep data manageable if no filter
  // But for simplicity, we rely on the API defaults or a 'limit' param already added above.
}

try {
  // 2. Fetch Data
  const response = await http(url);
  
  let features = [];
  if (response && response.features) {
      features = response.features;
  } else if (response && response.json) {
      const json = await response.json();
      features = json.features || [];
  }

  // 3. Handle Name/Text Filter (Client-Side)
  // filtering by 'place' property
  if (filters && filters.generic && filters.generic.length > 0) {
    const search = filters.generic.toLowerCase();
    features = features.filter(f => 
      f.properties.place && f.properties.place.toLowerCase().includes(search)
    );
  }

  // 4. Map to Table Columns
  // Configured Columns hint: 'place', 'magnitude', 'time', 'status'
  const tableData = features.map(f => {
    const props = f.properties;
    const dateObj = new Date(props.time);
    
    // Determine color based on magnitude
    let magColor = 'green';
    if (props.mag >= 5) magColor = 'red';
    else if (props.mag >= 3) magColor = 'orange';

    return {
      place: props.place,
      magnitude: {
          value: props.mag ? props.mag.toFixed(1) : '0.0',
          _style: `font-weight:bold; color: ${magColor};`
      },
      time: dateObj.toLocaleString(),
      status: `<a href="${props.url}" target="_blank">Ver Detalles</a>`
    };
  });

  callback(tableData);

} catch (error) {
  console.error("Error fetching earthquake data:", error);
  callback([]);
}

/**
 * Main function to retrieve and display entities
 * @param {Object} entityData - Context entity data
 * @param {Object} filters - Filters passed from the widget
 */

var builder = $api.entitiesSearchBuilder().limit(100).flattened();

// 1. Filter by parameter (assuming it comes in filters.generic or a specific field)
// Here we assume filters.generic contains a string to filter by name
if (filters && filters.generic) {
    builder.filter({
        like: {
            'provision.asset.name': filters.generic // Adjust field as needed (e.g., provision.device.name)
        }
    });
}

// 2. Sort by name
builder.sort([
    {
        column: 'provision.asset.name',
        direction: 'asc'
    }
]);

// 3. Execute query
var response = await builder.build().execute();

// 4. Transform results
var results = [];
if (response && response.data && response.data.entities) {
    response.data.entities.forEach(function(entity) {
            // Extract identifier (using bracket notation for flattened keys)
        var id = entity['provision.administration.identifier'] ? entity['provision.administration.identifier']._value._current.value : "Unknown";
        
        // Extract name (handle if it doesn't exist)
        var name = "N/A";
        if (entity['provision.asset.name']) {
            name = entity['provision.asset.name']._value._current.value;
        }

        results.push({
            identifier: id,
            name: name
        });
    });
}

return results;

// Main function executed by the Custom Table widget
// parameters: entityData, filters, page, pageElements, callback

// 1. Prepare Pagination Parameters
// Ensure we have defaults if arguments are missing (safeguard)
const currentPage = page || 1;
const perPage = pageElements || 5;

// 2. Construct URL with pagination params
// reqres.in uses 'page' (1-based) and 'per_page'
const url = `https://reqres.in/api/users?page=${currentPage}&per_page=${perPage}`;

try {
  // 3. Fetch Data
  const response = await http(url);
  
  // 4. Extract Data
  // reqres.in returns: { page: 1, per_page: 6, total: 12, total_pages: 2, data: [...] }
  let users = [];
  
  // Check various response wrappers as 'http' might auto-parse JSON
  if (response && response.data && Array.isArray(response.data)) {
      users = response.data;
  } else if (response && response.json) {
      const json = await response.json();
      users = json.data || [];
  } else if (response && Array.isArray(response)) {
      users = response;
  }

  // 5. Format for Table
  // Configured Columns hint: 'id', 'avatar', 'first_name', 'last_name'
  const tableData = users.map(user => {
    return {
      id: user.id,
      avatar: `<img src="${user.avatar}" style="width: 30px; border-radius: 50%;">`,
      first_name: user.first_name,
      last_name: user.last_name,
      email: user.email
    };
  });

  // 6. Return Data
  // We return the array of items for the current page.
  callback(tableData);

} catch (error) {
  console.error("Error fetching paged data:", error);
  callback([]);
}

var builder = $api.entitiesSearchBuilder().limit(100).flattened();

// Handle generic filter if present
if (filters && filters.generic) {
    builder.filter({
        like: {
            'provision.administration.identifier': filters.generic
        }
    });
}

var response = await builder.build().execute();

var results = [];
if (response && response.data && response.data.entities) {
    response.data.entities.forEach(function(entity) {
        // Get identifier
        var id = entity['provision.administration.identifier'] ? entity['provision.administration.identifier']._value._current.value : "Unknown";
        
        // Get battery charge (default to 0 if not present)
        var charge = 0;
        if (entity['device.powersupply.battery.charge']) {
            charge = entity['device.powersupply.battery.charge']._value._current.value;
        }

        // Create the chart configuration
        var pieOption = {
            color: ['#91c7ae', '#c23531'],
            series: [
                {
                    type: 'pie',
                    radius: ['50%', '70%'],
                    avoidLabelOverlap: false,
                    label: {
                        show: false,
                        position: 'center'
                    },
                    emphasis: {
                        label: {
                            show: true,
                            fontSize: '10',
                            fontWeight: 'bold'
                        }
                    },
                    labelLine: {
                        show: false
                    },
                    data: [
                        { value: charge, name: 'Charge' },
                        { value: 100 - charge, name: 'Empty' }
                    ]
                }
            ]
        };

        results.push({
            identifier: id,
            battery: {
                "_chart": pieOption,
                "_style": "height: 50px; width: 50px;" // Optional styling for the cell
            }
        });
    });
}

return results;

// Determine shape and color based on current milliseconds
const now = new Date();
const milliseconds = now.getMilliseconds();

// If milliseconds is even, draw a green circle. Else, a crimson rectangle.
const isEven = milliseconds % 2 === 0;
const color = isEven ? 'green' : 'crimson';
const shapeType = isEven ? 'circle' : 'rect';

console.log(`Milliseconds: ${milliseconds}. Drawing ${color} ${shapeType}.`);

try {
    // 1. Clear existing SVG content
    while (svgDom.firstChild) {
        svgDom.removeChild(svgDom.firstChild);
    }

    // 2. Create the new geometric shape
    const shape = document.createElementNS("http://www.w3.org/2000/svg", shapeType);

    if (shapeType === 'circle') {
        shape.setAttribute('cx', '50');
        shape.setAttribute('cy', '50');
        shape.setAttribute('r', '40');
    } else {
        shape.setAttribute('x', '10');
        shape.setAttribute('y', '10');
        shape.setAttribute('width', '80');
        shape.setAttribute('height', '80');
    }

    shape.setAttribute('fill', color);
    shape.setAttribute('stroke', 'black');
    shape.setAttribute('stroke-width', '2');

    // 3. Add text label
    const text = document.createElementNS("http://www.w3.org/2000/svg", "text");
    text.setAttribute('x', '50');
    text.setAttribute('y', '50');
    text.setAttribute('dominant-baseline', 'middle');
    text.setAttribute('text-anchor', 'middle');
    text.setAttribute('fill', 'white');
    text.setAttribute('font-family', 'Arial');
    text.setAttribute('font-size', '12');
    text.textContent = `ms: ${milliseconds}`;

    // 4. Append elements to SVG
    svgDom.appendChild(shape);
    svgDom.appendChild(text);

} catch (err) {
    console.error("Error in Open HMI script:", err);
    
    // Fallback display in SVG
    const text = document.createElementNS("http://www.w3.org/2000/svg", "text");
    text.setAttribute('x', '10');
    text.setAttribute('y', '20');
    text.setAttribute('fill', 'red');
    text.textContent = "Error executing script";
    svgDom.appendChild(text);
}

// Return the modified DOM
return svgDom;