import { Kind, parse, print, visit } from "graphql";
import client from "./GraphQLClient";
import { gql } from "@apollo/client";

/* eslint-disable no-loop-func */

/**
 * The available operators for filtering (string)
 * @type {[{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},null,null,null]}
 */
const STRING_OPERATORS = [
  { value: "_eq", label: "equals" },
  { value: "_neq", label: "does not equal" },
  { value: "_like", label: "contains" },
  { value: "_nlike", label: "does not contain" },
  { value: "_ilike", label: "contains case-insensitive" },
  { value: "_nilike", label: "does not contain case-insensitive" },
  { value: "_in", label: "in", type: "array" },
  { value: "_nin", label: "not in", type: "array" }
];

/**
 * The available operators for filtering (dates)
 * @type {[{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},null,null,null]}
 */
const DATE_OPERATORS = [
  { value: "_eq", label: "equals" },
  { value: "_neq", label: "does not equal" },
  { value: "_gt", label: "greater than" },
  { value: "_lt", label: "less than" },
  { value: "_gte", label: "greater than or equal" },
  { value: "_lte", label: "less than or equal" },
  { value: "_in", label: "in", type: "array" },
  { value: "_nin", label: "not in", type: "array" }
];

/**
 * The available operators for filtering (booleans)
 * @type {[{label: string, value: string},{label: string, value: string}]}
 */
const BOOLEAN_OPERATORS = [
  { value: "_eq", label: "equals" },
  { value: "_neq", label: "does not equal" }
];

/**
 * The available operators for filtering (numbers)
 * @type {[{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},null,null,null]}
 */
const NUMBER_OPERATORS = [
  { value: "_eq", label: "equals" },
  { value: "_neq", label: "does not equal" },
  { value: "_gt", label: "greater than" },
  { value: "_lt", label: "less than" },
  { value: "_gte", label: "greater than or equal" },
  { value: "_lte", label: "less than or equal" },
  { value: "_in", label: "in", type: "array" },
  { value: "_nin", label: "not in", type: "array" }
];

/**
 * The available operators for sorting
 * @type {[{label: string, value: string},{label: string, value: string}]}
 */
const ORDER_BY_OPERATORS = [
  { value: "asc", label: "ascending" },
  { value: "desc", label: "descending" }
];

/**
 * Get the available operators for filtering
 * @returns {[{label: string, value: string},{label: string, value: string}]}
 */
export function getOrderOperatorsByType() {
  return ORDER_BY_OPERATORS;
}

/**
 * Get the available operators for filtering
 * @param type
 * @returns {[{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},{label: string, value: string},null]}
 */
export function getWhereOperatorsByType(type = "string") {
  const operators = {
    string: STRING_OPERATORS,
    number: NUMBER_OPERATORS,
    boolean: BOOLEAN_OPERATORS,
    bool: BOOLEAN_OPERATORS,
    date: DATE_OPERATORS
  };
  return operators[type];
}

/**
 * Parse a GraphQL query into an AST
 * @param query
 * @returns {DocumentNode}
 */
export function parseQuery(query) {
  return parse(query);
}

/**
 * Print an AST back into a GraphQL query
 * @param query
 * @returns {string}
 */
export function printQuery(query) {
  return print(query);
}

/**
 * Generate a template based on the query and object
 * @param templateQueryToExecute
 * @param templateObject
 * @param useShopSpecificTemplate
 * @returns {Promise<{contextData: {}, useShopSpecificTemplate}>}
 */
export async function generateTemplate(templateQueryToExecute, templateObject, useShopSpecificTemplate) {
  // Advanced Filtering and Sorting modifications start here

  // Parse the query and apply the filters and sorters
  const ast = parseQuery(templateQueryToExecute);

  if (templateObject?.filters && templateObject?.filters?.length) {
    applyFilters(ast, templateObject.filters);
  }

  if (templateObject?.sorters && templateObject?.sorters?.length) {
    applySorters(ast, templateObject.sorters);
  } else if (templateObject?.defaultSorters && templateObject?.defaultSorters?.length) {
    applySorters(ast, templateObject.defaultSorters);
  }

  const finalQuery = printQuery(ast);

  // commented out for future revision debugging
  // console.log('Modified Query');
  // console.log(finalQuery);

  let contextData = {};
  if (templateQueryToExecute) {
    const { data } = await client.query({
      query: gql(finalQuery),
      variables: { ...templateObject.variables }
    });
    contextData = data;
  }

  return { contextData, useShopSpecificTemplate };
}

/**
 * Apply sorters to the AST
 * @param ast
 * @param sorters
 */
export function applySorters(ast, sorters) {
  sorters.forEach((sorter) => {
    const fieldPath = sorter.field.split(".");
    visit(ast, {
      OperationDefinition: {
        enter(node) {
          // Loop through each sorter to apply it
          // noinspection DuplicatedCode

          let currentSelection = node; // Start with the root operation

          // Navigate down the field path to the correct location
          for (let i = 0; i < fieldPath.length - 1; i++) {
            let found = false;
            visit(currentSelection, {
              Field: {
                enter(node) {
                  if (node.name.value === fieldPath[i]) {
                    currentSelection = node; // Move down to the next level
                    found = true;
                  }
                }
              }
            });
            if (!found) break; // Stop if we can't find the next field in the path
          }

          // Apply the sorter at the correct level
          if (currentSelection) {
            const targetFieldName = fieldPath[fieldPath.length - 1];
            let orderByArg = currentSelection.arguments.find((arg) => arg.name.value === "order_by");
            if (!orderByArg) {
              orderByArg = {
                kind: Kind.ARGUMENT,
                name: { kind: Kind.NAME, value: "order_by" },
                value: { kind: Kind.OBJECT, fields: [] }
              };
              currentSelection.arguments.push(orderByArg);
            }

            const sorterField = {
              kind: Kind.OBJECT_FIELD,
              name: { kind: Kind.NAME, value: targetFieldName },
              value: { kind: Kind.ENUM, value: sorter.direction } // Adjust if your schema uses a different type for sorting directions
            };

            // Add the new sorter condition
            orderByArg.value.fields.push(sorterField);
          }
        }
      }
    });
  });
}

/**
 * Apply Top Level Sub to the AST
 * @param node
 * @param fieldPath
 * @param filterField
 */
function applyTopLevelSub(node, fieldPath, filterField) {
  // Find or create the where argument for the top-level subfield
  let whereArg = node.selectionSet.selections
    .find((selection) => selection.name.value === fieldPath[0])
    ?.arguments.find((arg) => arg.name.value === "where");

  if (!whereArg) {
    whereArg = {
      kind: Kind.ARGUMENT,
      name: { kind: Kind.NAME, value: "where" },
      value: { kind: Kind.OBJECT, fields: [] }
    };
    const topLevelSubSelection = node.selectionSet.selections.find(
      (selection) => selection.name.value === fieldPath[0]
    );
    if (topLevelSubSelection) {
      topLevelSubSelection.arguments = topLevelSubSelection.arguments || [];
      topLevelSubSelection.arguments.push(whereArg);
    }
  }

  // Correctly position the nested filter without an extra 'where'
  if (fieldPath.length > 2) {
    // More than one level deep
    let currentField = whereArg.value;
    fieldPath.slice(1, -1).forEach((path, index) => {
      let existingField = currentField.fields.find((f) => f.name.value === path);
      if (!existingField) {
        existingField = {
          kind: Kind.OBJECT_FIELD,
          name: { kind: Kind.NAME, value: path },
          value: { kind: Kind.OBJECT, fields: [] }
        };
        currentField.fields.push(existingField);
      }
      currentField = existingField.value;
    });
    currentField.fields.push(filterField);
  } else {
    // Directly under the top level
    whereArg.value.fields.push(filterField);
  }
}

/**
 * Apply filters to the AST
 * @param ast
 * @param filters
 * @returns {ASTNode}
 */
export function applyFilters(ast, filters) {
  return visit(ast, {
    OperationDefinition: {
      enter(node) {
        filters.forEach((filter) => {
          const fieldPath = filter.field.split(".");
          let topLevel = false;
          let topLevelSub = false;

          // Determine if the filter should be applied at the top level
          if (fieldPath.length === 2) {
            topLevel = true;
          }

          if (fieldPath.length > 2 && fieldPath[0].startsWith("[") && fieldPath[0].endsWith("]")) {
            fieldPath[0] = fieldPath[0].substring(1, fieldPath[0].length - 1); // Strip the brackets
            topLevelSub = true;
          }

          // Construct the filter for a top-level application
          const targetFieldName = fieldPath[fieldPath.length - 1];

          let filterValue = createFilterValue(filter);
          let filterField = createFilterField(targetFieldName, filter, filterValue);

          if (topLevel) {
            applyTopLevelFilter(node, fieldPath, filterField);
          } else if (topLevelSub) {
            applyTopLevelSub(node, fieldPath, filterField);
          } else {
            applyNestedFilter(node, fieldPath, filterField);
          }
        });
      }
    }
  });
}

/**
 * Create a filter value based on the filter
 * @param filter
 * @returns {{kind: (Kind|Kind.INT), value}|{kind: Kind.LIST, values: *}}
 */
function createFilterValue(filter) {
  if (Array.isArray(filter.value)) {
    // If it's an array, create a list value with the array items
    return {
      kind: Kind.LIST,
      values: filter.value.map((item) => ({
        kind: getGraphQLKind(item),
        value: item
      }))
    };
  } else {
    // If it's not an array, use the existing logic
    return {
      kind: getGraphQLKind(filter.value),
      value: filter.value
    };
  }
}

/**
 * Create a filter field based on the target field and filter
 * @param targetFieldName
 * @param filter
 * @param filterValue
 * @returns {{kind: Kind.OBJECT_FIELD, name: {kind: Kind.NAME, value}, value: {kind: Kind.OBJECT, fields: [{kind: Kind.OBJECT_FIELD, name: {kind: Kind.NAME, value}, value}]}}}
 */
function createFilterField(targetFieldName, filter, filterValue) {
  return {
    kind: Kind.OBJECT_FIELD,
    name: { kind: Kind.NAME, value: targetFieldName },
    value: {
      kind: Kind.OBJECT,
      fields: [
        {
          kind: Kind.OBJECT_FIELD,
          name: { kind: Kind.NAME, value: filter.operator },
          value: filterValue
        }
      ]
    }
  };
}

/**
 * Apply a top-level filter to the AST
 * @param node
 * @param fieldPath
 * @param filterField
 */
function applyTopLevelFilter(node, fieldPath, filterField) {
  // Find or create the where argument for the top-level field
  let whereArg = node.selectionSet.selections
    .find((selection) => selection.name.value === fieldPath[0])
    ?.arguments.find((arg) => arg.name.value === "where");

  if (!whereArg) {
    whereArg = {
      kind: Kind.ARGUMENT,
      name: { kind: Kind.NAME, value: "where" },
      value: { kind: Kind.OBJECT, fields: [] }
    };
    const topLevelSelection = node.selectionSet.selections.find((selection) => selection.name.value === fieldPath[0]);
    if (topLevelSelection) {
      topLevelSelection.arguments = topLevelSelection.arguments || [];
      topLevelSelection.arguments.push(whereArg);
    }
  }

  // Correctly position the nested filter without an extra 'where'
  if (fieldPath.length > 2) {
    // More than one level deep
    let currentField = whereArg.value;
    fieldPath.slice(1, -1).forEach((path, index) => {
      let existingField = currentField.fields.find((f) => f.name.value === path);
      if (!existingField) {
        existingField = {
          kind: Kind.OBJECT_FIELD,
          name: { kind: Kind.NAME, value: path },
          value: { kind: Kind.OBJECT, fields: [] }
        };
        currentField.fields.push(existingField);
      }
      currentField = existingField.value;
    });
    currentField.fields.push(filterField);
  } else {
    // Directly under the top level
    whereArg.value.fields.push(filterField);
  }
}

/**
 * Apply a nested filter to the AST
 * @param node
 * @param fieldPath
 * @param filterField
 */
function applyNestedFilter(node, fieldPath, filterField) {
  // Initialize a reference to the current selection to traverse down the AST
  let currentSelection = node;

  // Iterate over the fieldPath, except for the last entry, to navigate the structure
  for (let i = 0; i < fieldPath.length - 1; i++) {
    const fieldName = fieldPath[i];
    let fieldFound = false;

    // Check if the current selection has a selectionSet and selections
    if (currentSelection.selectionSet && currentSelection.selectionSet.selections) {
      // Look for the field in the current selection's selections
      const selection = currentSelection.selectionSet.selections.find((sel) => sel.name.value === fieldName);
      if (selection) {
        // Move down the AST to the found selection
        currentSelection = selection;
        fieldFound = true;
      }
    }

    // If the field was not found in the current path, it's an issue
    if (!fieldFound) {
      console.error(`Field ${fieldName} not found in the current selection.`);
      return; // Exit the loop and function due to error
    }
  }

  // At this point, currentSelection should be the parent field where the filter needs to be applied
  // Check if the 'where' argument already exists in the current selection
  const whereArg = currentSelection.arguments.find((arg) => arg.name.value === "where");
  if (!whereArg) {
    // If not found, create a new 'where' argument for the current selection
    currentSelection.arguments.push({
      kind: Kind.ARGUMENT,
      name: { kind: Kind.NAME, value: "where" },
      value: { kind: Kind.OBJECT, fields: [] } // Empty fields array to be populated with the filter
    });
  }

  // Add the filter field to the 'where' clause of the current selection
  currentSelection.arguments.find((arg) => arg.name.value === "where").value.fields.push(filterField);
}

/**
 * Get the GraphQL kind for a value
 * @param value
 * @returns {Kind|Kind.INT}
 */
function getGraphQLKind(value) {
  if (Array.isArray(value)) {
    return Kind.LIST;
  } else if (typeof value === "number") {
    return value % 1 === 0 ? Kind.INT : Kind.FLOAT;
  } else if (typeof value === "boolean") {
    return Kind.BOOLEAN;
  } else if (typeof value === "string") {
    return Kind.STRING;
  } else if (value instanceof Date) {
    return Kind.STRING; // GraphQL does not have a Date type, so we return it as a string
  }
}

/* eslint-enable no-loop-func */