/**
 * Retrieves the list of currently enabled filter keywords.
 *
 * @returns {Keyword[]} An array of enabled filter keywords.
 */
function getEnabledFilterKeywords() {
    const filterKeywords = [];
    for (const [category, groups] of enabledFilterGroups) {
        for (const group of groups) {
            const keywords = filterCategories[category].filter_groups[group].keywords;
            for (let i = 0; i < keywords.length; i++) {
                if (keywords[i].enabled !== undefined && !keywords[i].enabled) {
                    continue;
                }
                if (!keywords[i].pattern) {
                    const caseSensitive = keywords[i].caseSensitive !== undefined ? keywords[i].caseSensitive : true;
                    if (keywords[i].regex) {
                        keywords[i].pattern = new RegExp(keywords[i].text, caseSensitive ? '' : 'i');
                    } else {
                        const escapedFilterText = keywords[i].text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                        keywords[i].pattern = new RegExp(escapedFilterText, caseSensitive ? '' : 'i');
                    }
                }
                filterKeywords.push(keywords[i]);
            }
        }
    }
    return filterKeywords;
}

/**
 * Filters logs by searching within the `message` field and retaining logs that match specific keywords.
 *
 * @param {Keyword[]} filterKeywords - An array of keywords to filter by.
 */
function filterItemsByFilterGroups(filterKeywords) {
    if (filterKeywords.length !== 0) {
        let new_items = [];
        const filterLimit = max_page_size;
        for (let i = 0; new_items.length < filterLimit && i < filtered_items.length; i++) {
            const log = filtered_items[i];
            if (filterKeywords.some(keyword => {
                const caseSensitive = keyword.caseSensitive !== undefined ? keyword.caseSensitive : true;
                if (keyword.regex) {
                    const pattern = keyword.pattern;
                    return pattern.test(log.message);
                } else {
                    return caseSensitive
                        ? log.message.includes(keyword.text)
                        : log.message.toLowerCase().includes(keyword.text.toLocaleLowerCase());
                }
            })) {
                new_items.push(filtered_items[i]);
            }
        }
        filtered_items = new_items;
    }
}
  

/**
 * Highlights keyword matches in text by wrapping them in a span with a background color.
 * Filters are sorted by descending length to avoid overlap. Missing colors are assigned programmatically.
 *
 * @param {string} text - The text to process.
 * @param {Keyword[]} filters - Array of filter keywords.
 * @returns {string} The processed HTML text with highlights.
 */
function highlightText(text, filters) {
    let highlighted = text;

    // Sort filters by length of text to avoid overlapping highlights
    filters.sort((a, b) => b.text.length - a.text.length);

    filters.forEach(filter => {
        // Assign color if not already set
        if (!filter.color) {
            filter.color = generateGoodColor();
        }
        // Use cached regex pattern for efficient matching
        highlighted = highlighted.replace(filter.pattern, (match) => {
            return `<span style="background-color: ${filter.color};">${match}</span>`;
        });
    });

    return highlighted;
}

if (!window.localStorage.getItem("fromDate")) {
    window.localStorage.setItem("fromDate", "");
} else {
    document.getElementById("from-timestamp").value = window.localStorage.getItem("fromDate");
}

if (!window.localStorage.getItem("toDate")) {
    window.localStorage.setItem("toDate", "");
} else {
    document.getElementById("to-timestamp").value = window.localStorage.getItem("toDate");
}

if (!window.localStorage.getItem("useDate")) {
    window.localStorage.setItem("useDate", "true");
} else if (window.localStorage.getItem("useDate") == "false") {
    document.getElementById("apply-date-chkbox").checked = false;
} else {
    document.getElementById("apply-date-chkbox").checked = true;
}
  

/**
 * Checks if the provided date string is valid.
 *
 * @param {string} dateString - The date string in the format "YYYY-MM-DDTHH:MM:SS.SSSZ".
 * @returns {boolean} True if the date string is valid, false otherwise.
 */
export const isValidDate = (dateString) => {
    if (dateString[dateString.length - 1] != 'Z') {
        return false;
    }
    dateString = dateString.substring(0, dateString.length - 1);
    const DateTimeSplit = dateString.split("T");
    const Date = DateTimeSplit[0].split("-");
    const Time = DateTimeSplit[1].split(":");

    if (Date.length != 3 || Time.length != 3) {
        return false;
    }
    if (!(("0000" <= Date[0] && Date[0] <= "9999") &&
          ("00" <= Date[1] && Date[1] <= "11") &&
          ("00" <= Date[2] && Date[2] <= "31"))) {
        return false;
    }
    if (!(("00" <= Time[0] && Time[0] <= "59") &&
          ("00" <= Time[1] && Time[1] <= "59"))) {
        return false;
    }
    const SecondsSplit = Time[2].split(".");
    if (!(("00" <= SecondsSplit[0] && SecondsSplit[0] <= "59") &&
          ("000" <= SecondsSplit[1] && SecondsSplit[1] <= "999"))) {
        return false;
    }
    return true;
}

/**
 * Determines if a log record's timestamp falls within the user-defined date range.
 *
 * @param {Object} log - The log record object containing a "timestamp" property.
 * @returns {boolean} True if the log's timestamp is within the date range or if date filtering is disabled.
 */
export const isWithinDate = (log) => {
    if (!document.getElementById("apply-date-chkbox").checked) {
        return true;
    }
    const fromTimeStamp = document.getElementById("from-timestamp").value;
    const toTimeStamp = document.getElementById("to-timestamp").value;
    if (fromTimeStamp === "" || toTimeStamp === "") {
        return true;
    }
    if (!isValidDate(fromTimeStamp) || !isValidDate(toTimeStamp)) {
        console.log("INVALID TIMESTAMPS");
        return false;
    }
    const logTimeStamp = log["timestamp"];
    return (fromTimeStamp <= logTimeStamp && logTimeStamp <= toTimeStamp);
}
  

/**
* Schedule a callback when idle.
* @param {Function} callback - The function to schedule.
* @param {string} id - Table identifier for the scheduled chunk.
*/
const scheduleChunkFor = (callback, id) => {
    if (window.requestIdleCallback) {
        scheduledChunks[id] = requestIdleCallback(callback);
    } else {
        scheduledChunks[id] = setTimeout(callback, 0);
    }
};

/**
 * Cancel a scheduled callback.
 * @param {string} id - Identifier for the scheduled chunk.
 */
const cancelScheduledChunkFor = (id) => {
    if (scheduledChunks[id] !== null) {
        if (window.cancelIdleCallback) {
            cancelIdleCallback(scheduledChunks[id]);
        } else {
            clearTimeout(scheduledChunks[id]);
        }
        scheduledChunks[id] = null;
    }
};

/**
 * Applies filters incrementally and asynchronously to log entries.
 * 
 * @param {Array} filters - Array of filters to apply to log entries.
 */
 export const applyFilters = (filters) => {
    cancelScheduledChunkFor("all-logs");
    cancelScheduledChunkFor("filtered-logs");

    // Clear tables and render headers.
    document.getElementById("all-logs-table").innerHTML = "";
    document.getElementById("filtered-logs-table").innerHTML = "";
    renderHeader("all-logs");
    renderHeader("filtered-logs");

    const filteredLogs = [];
    const chunkSize = ROWS_PER_PAGE; // adjust as needed
    let lastFilteredRenderIndex = 0;
    let i = 0;

    function processChunk() {
        const chunkStart = i;
        const end = Math.min(i + chunkSize, allLogs.length);
        for (; i < end; i++) {
            const log = allLogs[i];
            if (!isWithinDate(log)) continue;

            // Check filters and add matching logs.
            if (checkMatch(log, filters)) {
                filteredLogs.push(log);
            }
        }

        // Always render the processed chunk for all logs.
        renderChunk(allLogs, chunkStart, i, "all-logs", filters);

        // Render any new filtered logs that have been added.
        if (filteredLogs.length > lastFilteredRenderIndex) {
            renderChunk(
                filteredLogs,
                lastFilteredRenderIndex,
                filteredLogs.length,
                "filtered-logs",
                filters
            );
            lastFilteredRenderIndex = filteredLogs.length;
        }

        if (i < allLogs.length) {
            scheduleChunkFor(processChunk, "all-logs");
        }
    }

    processChunk();
};

/**
 * Renders a chunk of log entries into a specified table and updates its pagination.
 *
 * This function takes an array of log objects and renders a subset (chunk) defined by the start and end indices
 * into a table body identified by the provided `id` parameter. This allows us to use the same rendering code for multiple
 * tables (for example, one for filtered logs and another for a different view) by simply specifying a different `id`.
 *
 * @param {Object[]} logs - Array of log objects to render.
 * @param {number} start - The starting index (inclusive) of the log chunk to render.
 * @param {number} end - The ending index (exclusive) of the log chunk to render.
 * @param {string} [id="filtered-logs"] - Identifier for selecting which table to render to. The table body element should have an ID in the format `${id}-tbody`.
 * @param {Array} [filters=[]] - Array of filter keywords to use for highlighting text within each log entry.
 */
export const renderChunk = (logs, start, end, id = "filtered-logs", filters = []) => {
    if (logs.length === 0) {
        console.log("No logs to render.");
        return;
    }
    
    // Retrieve the table body element by constructing the element's ID.
    const tbody = document.getElementById(`${id}-tbody`);
    if (!tbody) {
        console.error(`Table body element with id "${id}-tbody" not found.`);
        return;
    }
    
    // Extract headers from the first log object (assuming all logs share the same structure).
    const headers = Object.keys(logs[0]);
    const rows = [];
    
    // Generate table rows for each log in the specified chunk.
    for (let i = start; i < end && i < logs.length; i++) {
        const log = logs[i];
        rows.push(`
            <tr id="log-${log.id}">
                ${headers.map(header => `<td>${highlightText(String(log[header]), filters)}</td>`).join('')}
            </tr>
        `);
    }
    
    // Append the generated rows to the table body.
    tbody.insertAdjacentHTML('beforeend', rows.join(''));

    // Update the pagination controls for the table specified by the id.
    renderPagination(id);
};
            

// Initialize the vertical split-pane with Split.js
Split(['#all-logs-pane', '#filtered-logs-pane'], {
    direction: 'vertical',
    sizes: [50, 50],
    gutterSize: 5,
    minSize: 100,
    gutter: (index, direction) => {
        const gutter = document.createElement('div');
        gutter.className = `gutter gutter-${direction}`;
        gutter.style.height = '10px';
        gutter.style.cursor = 'row-resize';
        gutter.style.position = 'relative';

        const line = document.createElement('div');
        line.style.position = 'absolute';
        line.style.top = '50%';
        line.style.left = '0';
        line.style.right = '0';
        line.style.height = '5px';
        line.style.backgroundColor = '#ccc';
        line.style.transform = 'translateY(-50%)';

        gutter.appendChild(line);
        return gutter;
    }
});

// Handle click events on rows within the filtered logs table.
const filteredTable = document.getElementById("filtered-logs-table");
if (filteredTable) {
    filteredTable.addEventListener("click", (e) => {
        // Identify the clicked row, even if a child element was clicked.
        const clickedRow = e.target.closest("tr");
        if (clickedRow && clickedRow.id) {
            const rowId = clickedRow.id; // Format "log-"
            const rowNum = parseInt(rowId.replace("log-", ""), 10);
            const targetPage = Math.floor((rowNum - 1) / ROWS_PER_PAGE);

            // Navigate the "All Logs" table to the corresponding page.
            if (window.allLogsPageUpdater) {
                window.allLogsPageUpdater(targetPage);
            }

            // Brief delay to ensure the target row is visible before scrolling and highlighting.
            setTimeout(() => {
                const fullRow = document.querySelector(`#all-logs-table tr#${rowId}`);
                if (fullRow) {
                    fullRow.scrollIntoView({ behavior: "smooth", block: "center" });
                    fullRow.classList.add("highlight");
                    setTimeout(() => fullRow.classList.remove("highlight"), 2000);
                }
            }, 150);
        }
    });
}

// Processes streamed server-sent events (SSE)
const processStream = async (stream, messagesContainer, loadingMessage) => {
  const decoder = new TextDecoder("utf-8");
  const reader = stream.getReader();
  let buffer = "";

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    let parts = buffer.split("\n\n");
    buffer = parts.pop();

    for (const part of parts) {
      if (part.startsWith("data: ")) {
        const dataStr = part.substring(6).trim();
        if (dataStr === "[DONE]") {
          break;
        }
        try {
          const action = JSON.parse(dataStr);
          processAction(action, messagesContainer);
        } catch (e) {
          console.error("Error parsing action", e);
        }
      }
    }
  }

  // Remove loading message after streaming is complete
  loadingMessage?.remove();
};
  

const processAction = (action, messagesContainer) => {
  let messageEl = document.createElement("div");
  messageEl.className = "chat-message bot";

  switch (action.type) {
    case "summary_decision":
    case "issue_decision":
    case "filter_decision":
      messageEl.innerHTML = `
        <div class="thinking-header">
          <span>${action.type.replace("_", " ")}</span>
          <span class="animated-ellipsis">...</span>
        </div>
        <div class="thinking-details" style="display:none">${action.body.explanation}</div>
      `;
      messageEl.querySelector(".thinking-header").onclick = () => {
        const details = messageEl.querySelector(".thinking-details");
        details.style.display = details.style.display === "none" ? "block" : "none";
      };
      messagesContainer.appendChild(messageEl);
      if (!action.body.generate_summary && !action.body.evaluate_issues && !action.body.should_add_filter) {
        setTimeout(() => messageEl.remove(), 3000);
      }
      break;

    case "add_filter":
      extendFilterGroups([action.body.filter_group]);
      let filterContent = `
        <strong>Filter Group Added: ${action.body.filter_group.title}</strong>
        <p>${action.body.filter_group.description}</p>
        <table>
          <thead><tr><th>Keyword</th><th>Description</th></tr></thead>
          <tbody>
      `;
      action.body.filter_group.filters.forEach(filter => {
        filterContent += `
          <tr>
            <td><span style="background-color:${filter.color}">${filter.text}</span></td>
            <td>${filter.description}</td>
          </tr>
        `;
      });
      filterContent += "</tbody></table>";
      messageEl.innerHTML = filterContent;
      messagesContainer.appendChild(messageEl);
      break;

    case "generate_summary":
      messageEl.innerHTML = marked.parse(createMarkdownTable(action.body.stats) + "\n" + action.body.summary);
      messagesContainer.appendChild(messageEl);
      break;

    case "flag_issue":
      messageEl.innerHTML = `
        <div class="flag-issue-header">
          <strong style="color:#950606">Detected issue: ${action.body.issue}</strong>
          <span>▼</span>
        </div>
        <div class="flag-issue-details" style="display:none">${marked.parse(action.body.summary)}</div>
      `;
      messageEl.querySelector(".flag-issue-header").onclick = () => {
        const details = messageEl.querySelector(".flag-issue-details");
        details.style.display = details.style.display === "none" ? "block" : "none";
      };
      messagesContainer.appendChild(messageEl);
      break;
  }

  messagesContainer.scrollTop = messagesContainer.scrollHeight;
};