import { Repository } from "typeorm";
import {
  Company,
  getStatusVerifyLocalNumber,
  getTimeZone,
  getTimezoneOffset,
  Partner,
} from "..";
import { IPropsQueryVerifyLocalInformation } from "../interfaces";

export async function getVerifyLocalsInformation(
  repository: Repository<any>,
  {
    status,
    lazyEvent,
    partner,
    assigned_master,
  }: IPropsQueryVerifyLocalInformation
) {
  try {
    const timezone = getTimezoneOffset(getTimeZone());

    const queryBuilder = repository
      .createQueryBuilder("verify_local")
      .skip(lazyEvent.first)
      .take(lazyEvent.rows);

    //DOC:  Filtro global
    if (lazyEvent.filters["global"] && lazyEvent.filters["global"].value) {
      const globalValue = `%${lazyEvent.filters[
        "global"
      ].value.toLowerCase()}%`;
      queryBuilder.andWhere(
        '(LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.local_information, "$.name"))) LIKE :globalValue OR LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.local_information, "$.addressElement"))) LIKE :globalValue OR LOWER(verify_local.company_name) LIKE :globalValue OR LOWER(verify_local.partner_name) LIKE :globalValue OR LOWER(verify_local.partner_document) LIKE :globalValue)',
        { globalValue }
      );
    }

    //DOC: Filtro por estado FILTRO POR DEFECTO
    if (status !== null && status >= 0) {
      queryBuilder.andWhere("verify_local.status = :status", { status });
    }

    //DOC: Filtro por partner FILTRO POR DEFECTO
    if (partner !== null && partner >= 0) {
      queryBuilder.andWhere("verify_local.partner = :partner", { partner });
    }

    //DOC: Filtro por assigned_master FILTRO POR DEFECTO
    if (assigned_master !== null && assigned_master >= 0) {
      queryBuilder.andWhere("verify_local.assigned_master = :assigned_master", {
        assigned_master,
      });
    }

    //DOC: Aplicación de filtros adicionales
    const filters = lazyEvent.filters;
    Object.keys(filters).forEach((key) => {
      if (filters[key] && filters[key].value) {
        const matchMode = filters[key].matchMode;

        if (key === "status") {
          queryBuilder.andWhere("verify_local.status = :status", {
            status: getStatusVerifyLocalNumber(filters[key].value ?? ""),
          });
        } else if (key === "created") {
          const value = filters[key].value.split("T")[0];

          switch (matchMode) {
            case "dateIs":
              queryBuilder.andWhere(
                `DATE(CONVERT_TZ(verify_local.created, '+00:00', '${timezone}')) = :created`,
                { created: value }
              );
              break;
            case "dateBefore":
              queryBuilder.andWhere(
                `DATE(CONVERT_TZ(verify_local.created, '+00:00', '${timezone}')) < :created`,
                { created: value }
              );
              break;
            case "dateAfter":
              queryBuilder.andWhere(
                `DATE(CONVERT_TZ(verify_local.created, '+00:00', '${timezone}')) > :created`,
                { created: value }
              );
              break;
            case "dateIsNot":
              queryBuilder.andWhere(
                `DATE(CONVERT_TZ(verify_local.created, '+00:00', '${timezone}')) != :created`,
                { created: value }
              );
              break;
            default:
              break;
          }
        } else if (
          key !== "global" &&
          ((Array.isArray(filters[key].value) &&
            filters[key].value.length > 0) ||
            (!Array.isArray(filters[key].value) && filters[key].value))
        ) {
          let value = filters[key].value;
          if (!Array.isArray(value) && value) {
            value = filters[key].value.toLowerCase();
          }
          const jsonPath = key
            .split(".")
            .slice(1)
            .map((segment) => `$.${segment}`)
            .join("");
          const paramKey = key.split(".")[1];

          switch (matchMode) {
            case "contains":
              queryBuilder.andWhere(
                `LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.${
                  key.split(".")[0]
                }, "${jsonPath}"))) LIKE :${paramKey}`,
                { [paramKey]: `%${value}%` }
              );
              break;
            case "startsWith":
              queryBuilder.andWhere(
                `LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.${
                  key.split(".")[0]
                }, "${jsonPath}"))) LIKE :${paramKey}`,
                { [paramKey]: `${value}%` }
              );
              break;
            case "notContains":
              queryBuilder.andWhere(
                `LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.${
                  key.split(".")[0]
                }, "${jsonPath}"))) NOT LIKE :${paramKey}`,
                { [paramKey]: `%${value}%` }
              );
              break;
            case "endsWith":
              queryBuilder.andWhere(
                `LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.${
                  key.split(".")[0]
                }, "${jsonPath}"))) LIKE :${paramKey}`,
                { [paramKey]: `%${value}` }
              );
              break;
            case "equals":
              if (key === "partner_document") {
                const partnerIds = value.map((element: Partner) => element.id);

                if (partnerIds.length > 0) {
                  queryBuilder.andWhere(
                    "verify_local.partner_id IN (:...partnerIds)",
                    {
                      partnerIds,
                    }
                  );
                }
              } else if (key === "company_name") {
                const companyIds = value.map((element: Company) => element.id);

                if (companyIds.length > 0) {
                  queryBuilder.andWhere(
                    "verify_local.company_id IN (:...companyIds)",
                    {
                      companyIds,
                    }
                  );
                }
              } else {
                queryBuilder.andWhere(
                  `LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.${
                    key.split(".")[0]
                  }, "${jsonPath}"))) = :${paramKey}`,
                  { [paramKey]: value }
                );
              }
              break;
            case "notEquals":
              queryBuilder.andWhere(
                `LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.${
                  key.split(".")[0]
                }, "${jsonPath}"))) != :${paramKey}`,
                { [paramKey]: value }
              );
              break;
            default:
              break;
          }
        }
      }
    });

    //DOC: Ordenamiento
    if (lazyEvent.sortField) {
      const order = lazyEvent.sortOrder === 1 ? "ASC" : "DESC";
      if (lazyEvent.sortField.startsWith("local_information.")) {
        const jsonPath = lazyEvent.sortField
          .split(".")
          .slice(1)
          .map((segment: any) => `$.${segment}`)
          .join("");
        queryBuilder.orderBy(
          `LOWER(JSON_UNQUOTE(JSON_EXTRACT(verify_local.local_information, '${jsonPath}')))`,
          order
        );
      } else {
        queryBuilder.orderBy(lazyEvent.sortField, order);
      }
    }

    const [data, total] = await queryBuilder.getManyAndCount();

    return {
      data,
      totalRecords: total,
    };
  } catch (error) {
    return {
      data: [],
      totalRecords: 0,
    };
  }
}