import { AsyncLocalStorage } from "async_hooks";
import { config } from "dotenv";
import { NextFunction, Request, Response } from "express";
import { resolve } from "path";
import { DataSource, EntityTarget, ObjectLiteral, Repository } from "typeorm";
import * as EntitiesViewsRoutes from "./entities.index";
import {
  getDiscountsCodeCompanyInformation,
  getDiscountsCodeUserInformation,
  getLocalReservesInformation,
  getLocalsCompanyInformation,
  getLocalsCompanyInformationTable,
  getVerifyLocalsInformation
} from "./entities.views.routes";
import {
  IBasicCompany,
  IBasicLazyEvent,
  IPropsDiscountUserOrCompany,
  IPropsLocalReserve,
  IPropsQueryVerifyLocalInformation,
  IType,
} from "./interfaces";
import moment = require("moment-timezone");
export * from "./entities.views.routes";

const asyncLocalStorage = new AsyncLocalStorage<Map<string, string>>();

let connection: DataSource | null = null;

// DOCUMENTATION: Función para crear la conexión de la base de datos
// AUTHOR: jgomezp97@gmail.com
export function createDataBaseSource(): DataSource {
  if (!connection) {
    config({ path: resolve(process.cwd(), ".env") });

    connection = new DataSource({
      type: process.env.DB_TYPE as unknown as IType,
      // dateStrings: true,
      dateStrings: ["DATE"],
      host: process.env.DB_HOST,
      port: parseInt(process.env.DB_PORT ?? ""),
      username: process.env.DB_USERNAME,
      password: process.env.DB_PASSWORD ?? "",
      database: process.env.DB_DATABASE,
      synchronize: process.env.DB_SYNCHRONIZE === "true",
      timezone: "Z", // Configura la zona horaria a UTC
      entities: Object.values(EntitiesViewsRoutes),
      // entities: [
      //   __dirname +
      //     `/entities${
      //       process.env.DB_ENTITIES_ROUTE
      //         ? `/${process.env.DB_ENTITIES_ROUTE}`
      //         : ""
      //     }/*{.js,.ts}`,
      //   __dirname +
      //     `/views${
      //       process.env.DB_ENTITIES_ROUTE
      //         ? `/${process.env.DB_ENTITIES_ROUTE}`
      //         : ""
      //     }/*{.js,.ts}`,
      // ],
      subscribers: [],
      migrations: [],
    });
  }
  return connection;
}

// DOCUMENTATION: Función para retornar la entidad de una base de datos en específico por medio de un DataSource
// AUTHOR: jgomezp97@gmail.com
export async function showEntityNameEntity<T extends ObjectLiteral>(
  entity: EntityTarget<T>,
): Promise<Repository<T>> {
  if (!connection || !connection.isInitialized) {
    connection = createDataBaseSource();
    await connection.initialize();
  }
  return connection.getRepository(entity);
}

export async function showEntity(entityName: string): Promise<any> {
  if (!connection) {
    connection = createDataBaseSource();
    await connection.initialize();
  }

  return connection.getRepository(entityName);
}

export async function callStoredProcedure(storedProcedure: any, elements: any) {
  try {
    if (!connection) {
      connection = createDataBaseSource();
      await connection.initialize();
    }

    const result = await connection.query(`CALL ${storedProcedure}`, elements);
    return result;
  } catch (error) {
    throw error;
  }
}

export function timezoneMiddleware(
  req: Request,
  res: Response,
  next: NextFunction,
) {
  let userTimeZone = req.headers["user-timezone"];

  if (Array.isArray(userTimeZone)) {
    userTimeZone = userTimeZone[0];
  }

  userTimeZone = userTimeZone || "UTC";

  asyncLocalStorage.run(new Map([["timezone", userTimeZone]]), () => {
    next();
  });
}

export function getTimeZone(): string {
  const store = asyncLocalStorage.getStore();
  console.log(store, "store");
  console.log(store?.get("timezone"), "y");

  return store?.get("timezone") ?? "UTC";
}

export function getTimezoneOffset(timezone: string) {
  const now = moment.tz(timezone);
  const offset = now.format("Z");
  return offset;
}

export const getRepositoryByEntity = async <T extends ObjectLiteral>(
  entity: EntityTarget<T>,
) => {
  if (!connection || !connection.isInitialized) {
    connection = createDataBaseSource();
    await connection.initialize();
  }

  return connection.getRepository(entity).extend({
    async getDiscountsCodeUserWrapper(params: IPropsDiscountUserOrCompany) {
      return getDiscountsCodeUserInformation(this, params);
    },

    async getDiscountsCodeCompanyWrapper(params: IBasicLazyEvent) {
      return getDiscountsCodeCompanyInformation(this, params);
    },

    async getLocalsCompanyInformationWrapper(params: IBasicCompany) {
      return getLocalsCompanyInformation(this, params);
    },

    async getVerifyLocalsInformationWrapper(
      params: IPropsQueryVerifyLocalInformation,
    ) {
      return getVerifyLocalsInformation(this, params);
    },

    async getLocalReservesInformationWrapper(params: IPropsLocalReserve) {
      return getLocalReservesInformation(this, params);
    },

    async getLocalsCompanyInformationForTheTableWrapper(params: IBasicCompany) {
      return getLocalsCompanyInformationTable(this, params);
    },
  });
};

// export const getRepositoryByEntity = async <T extends ObjectLiteral>(
//   entity: EntityTarget<T>,
// ): Promise<CustomRepository<T>> => {
//   if (!connection || !connection.isInitialized) {
//     connection = createDataBaseSource();
//     await connection.initialize();
//     console.log(
//       "METADATA CARGADA:",
//       connection.entityMetadatas.map((e) => e.name),
//     );
//   }

//   return connection
//     .getRepository(entity)
//     .extend(CustomRepository.prototype) as CustomRepository<T>;
// };
// export const getRepositoryByEntity = async <T extends ObjectLiteral>(
//   entity: EntityTarget<T>,
// ): Promise<CustomRepository<T>> => {
//   if (!connection) {
//     connection = createDataBaseSource();
//     await connection.initialize();
//   }
//   return connection
//     .getRepository(entity)
//     .extend(CustomRepository.prototype) as CustomRepository<T>;
// };
// export const getRepositoryByEntity = async <T extends ObjectLiteral>(
//   entity: EntityTarget<T>,
// ): Promise<CustomRepository<T>> => {
//   if (!connection) {
//     connection = createDataBaseSource();
//     await connection.initialize();

//     console.log(connection.entityMetadatas.map((e) => e.name));
//   }

//   return new CustomRepository<T>(entity, connection);
// };