import { randomBytes } from "crypto";

import { inject, injectable } from "inversify";
import { FilterQuery, isValidObjectId, startSession } from "mongoose";

import { CompleteRespirationLegalDTO, CompleteRespirationRealDTO } from "./DTO/complete-register.dto";
import { CreateDocumentTypeDTO } from "./DTO/createDocumentType";
import { LegalSellerUpdateDto, RealSellerUpdateDto } from "./DTO/sellerUpdate.dto";
import { BusinessTypeEnum } from "./enum/seller.enum";
import { DocumentTypeRepo } from "./repository/documentType.repository";
import { LegalSellerRepo } from "./repository/legalSeller.repository";
import { SellerContractRepo } from "./repository/sellerContract.repository";
import { SellerStatusRepo } from "./repository/sellerStatus.repository";
import { SellerRepository } from "./seller.repository";
import { PaginationDTO } from "../../common/dto/pagination.dto";
import {
  AddressMessage,
  AuthMessage,
  CommonMessage,
  ContractMessage,
  SellerMessage,
  SetShipmentMessage,
  ShopMessage,
} from "../../common/enums/message.enum";
import { OrderItemsStatus } from "../../common/enums/order.enum";
import { BadRequestError } from "../../core/app/app.errors";
import { IOCTYPES } from "../../IOC/ioc.types";
import { contractTemplate } from "../../template/contract";
import { ChatService } from "../chat/chat.service";
import { OrderItemRepo } from "../order/order.repository";
import { CommentRepository } from "../product/Repository/comment";
import { ProductRepository } from "../product/Repository/product";
import { ProductVariantRepository } from "../product/Repository/productVarinat";
import { OwnerRef } from "../shop/models/Abstraction/IShop";
import { ShopRepo } from "../shop/shop.repository";
import { ShopService } from "../shop/shop.service";
import { UploadSellerDocumentDTO } from "./DTO/update-sellerDocument.dto";
import { UpdateShopShipmentDTO } from "./DTO/update-shop-shipment.dto";
import { ILegalSeller } from "./models/Abstraction/ILegal-seller";
import { IRealSeller } from "./models/Abstraction/IReal-seller";
import { RealSellerRepo } from "./repository/realSeller.repository";
import { SellerDocumentRepo } from "./repository/sellerDocument.repository";
import { ContractType } from "./types/contract.types";
import { ContractRepository } from "../admin/repository/contract";
import { ISeller } from "./models/Abstraction/ISeller";
import { WholesaleRequestRepo } from "./repository/wholesaleRequest.repositroy";
import { StatusEnum } from "../../common/enums/status.enum";
import { paginationUtils } from "../../utils/pagination.utils";
import { UpdateSellerDocumentDto } from "../admin/DTO/updateSellerDocument.dto";
import { NotificationService } from "../notification/notification.service";
import { TicketService } from "../ticket/ticket.service";

@injectable()
class SellerService {
  @inject(IOCTYPES.SellerRepository) sellerRepo: SellerRepository;
  @inject(IOCTYPES.ProductRepository) productRepo: ProductRepository;
  @inject(IOCTYPES.ProductVariantRepository) productVariantRepo: ProductVariantRepository;
  @inject(IOCTYPES.OrderItemRepo) orderItemRepo: OrderItemRepo;
  @inject(IOCTYPES.ShopService) shopService: ShopService;
  @inject(IOCTYPES.ShopRepo) shopRepo: ShopRepo;
  @inject(IOCTYPES.WholesaleRequestRepo) wholesaleRequestRepo: WholesaleRequestRepo;
  @inject(IOCTYPES.SellerStatusRepo) sellerStatusRepo: SellerStatusRepo;
  @inject(IOCTYPES.RealSellerRepo) realSellerRepo: RealSellerRepo;
  @inject(IOCTYPES.LegalSellerRepo) legalSellerRepo: LegalSellerRepo;
  @inject(IOCTYPES.SellerDocumentRepo) sellerDocumentRepo: SellerDocumentRepo;
  @inject(IOCTYPES.SellerContractRepo) sellerContractRepo: SellerContractRepo;
  @inject(IOCTYPES.DocumentTypeRepo) documentTypeRepo: DocumentTypeRepo;
  @inject(IOCTYPES.CommentRepository) commentRepo: CommentRepository;
  @inject(IOCTYPES.ContractRepository) contractRepo: ContractRepository;
  @inject(IOCTYPES.NotificationService) notificationService: NotificationService;
  @inject(IOCTYPES.TicketService) ticketService: TicketService;
  @inject(IOCTYPES.ChatService) chatService: ChatService;

  //###################################

  // async getSellers(queryDto: PaginationDTO) {
  //   const { limit, skip } = paginationUtils(queryDto);
  //   const count = await this.sellerRepo.model.countDocuments();
  //   const sellers = await this.sellerRepo.model.find().skip(skip).limit(limit).lean();
  //   return { sellers, count };
  // }

  //#############
  async getSellersWithDocumentsAndContracts(queryDto: PaginationDTO) {
    const { limit, skip } = paginationUtils(queryDto);
    const count = await this.sellerRepo.model.countDocuments();
    const sellers = await this.sellerRepo.model.aggregate([
      {
        $lookup: {
          from: "sellerdocuments",
          localField: "_id",
          foreignField: "seller",
          as: "documents",
        },
      },
      {
        $lookup: {
          from: "shops",
          localField: "_id",
          foreignField: "owner",
          as: "shop",
        },
      },
      {
        $unwind: "$shop",
      },
      {
        $lookup: {
          from: "sellercontracts",
          localField: "_id",
          foreignField: "seller",
          as: "contracts",
        },
      },
      {
        $unwind: {
          path: "$contracts",
          preserveNullAndEmptyArrays: true,
        },
      },
      { $skip: skip },
      { $limit: limit },
    ]);
    return { sellers, count };
  }

  async getSellerById(sellerId: string) {
    if (!isValidObjectId(sellerId)) throw new BadRequestError(CommonMessage.NotValidId);
    const seller = await this.sellerRepo.model.findById(sellerId).lean();
    if (!seller) throw new BadRequestError(SellerMessage.SellerNotFound);
    return {
      seller,
    };
  }

  //###################################

  async approveSellerRegistration(sellerId: string) {
    const session = await startSession();
    session.startTransaction();
    try {
      if (!isValidObjectId(sellerId)) throw new BadRequestError(CommonMessage.NotValidId);

      const seller = await this.sellerRepo.model.findById(sellerId);
      if (!seller) throw new BadRequestError(SellerMessage.SellerNotFound);

      const sellerStatus = await this.sellerStatusRepo.model.findOne({ seller: sellerId });
      if (!sellerStatus) throw new BadRequestError(SellerMessage.StatusNotFound);

      if (sellerStatus.register && seller.accountStatus === StatusEnum.Approved) {
        seller.accountStatus = StatusEnum.Pending;
        sellerStatus.register = false;
        await this.notificationService.notifyDeactive(sellerId, session);
      } else {
        sellerStatus.register = true;
        seller.accountStatus = StatusEnum.Approved;
      }

      await sellerStatus.save({ session });

      await seller.save({ session });

      await session.commitTransaction();

      return {
        message: CommonMessage.Updated,
        status: sellerStatus,
      };
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      await session.endSession();
    }
  }

  //###################################

  async updateSellerDocumentStatus(sellerId: string, updateDto: UpdateSellerDocumentDto) {
    if (!isValidObjectId(sellerId)) throw new BadRequestError(CommonMessage.NotValidId);

    const seller = await this.sellerRepo.model.findById(sellerId);
    if (!seller) throw new BadRequestError(SellerMessage.SellerNotFound);

    const document = await this.sellerDocumentRepo.model.findOneAndUpdate(
      { _id: updateDto.docsId, seller: sellerId },
      { status: updateDto.status },
    );

    if (!document) throw new BadRequestError(SellerMessage.SellerDocumentNotFound);

    return {
      message: CommonMessage.Updated,
      status: document.status,
    };
  }

  //###################################

  async deleteSellerDocument(documentId: string, rejectReason: string) {
    const document = await this.sellerDocumentRepo.model.findByIdAndDelete(documentId);
    if (!document) throw new BadRequestError(SellerMessage.SellerDocumentNotFound);
    await this.notificationService.notifyRejectDocument(document.seller.toString(), rejectReason);
    return {
      message: CommonMessage.Deleted,
    };
  }

  //###################################

  async approveSellerContract(sellerId: string) {
    const session = await startSession();
    session.startTransaction();
    try {
      if (!isValidObjectId(sellerId)) throw new BadRequestError(CommonMessage.NotValidId);

      const seller = await this.sellerRepo.model.findById(sellerId).session(session);
      if (!seller) throw new BadRequestError(SellerMessage.SellerNotFound);

      const sellerStatus = await this.sellerStatusRepo.model.findOne({ seller: sellerId }).session(session);
      if (!sellerStatus) throw new BadRequestError(SellerMessage.StatusNotFound);

      sellerStatus.contract = true;

      await sellerStatus.save({ session });

      this.notificationService.notifyApproveContract(sellerId, session);

      await session.commitTransaction();

      return {
        message: CommonMessage.Updated,
        status: sellerStatus,
      };
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      await session.endSession();
    }
  }

  //###################################

  async approveSellerWholesale(requestId: string) {
    const session = await startSession();
    session.startTransaction();
    try {
      if (!isValidObjectId(requestId)) throw new BadRequestError(CommonMessage.NotValidId);

      const wholesaleRequest = await this.wholesaleRequestRepo.model.findById(requestId).session(session);
      if (!wholesaleRequest) throw new BadRequestError(SellerMessage.WholesaleRequestNotFound);

      const seller = await this.sellerRepo.model.findById(wholesaleRequest.seller).session(session);
      if (!seller) throw new BadRequestError(SellerMessage.SellerNotFound);

      wholesaleRequest.status = StatusEnum.Approved;

      seller.isWholesaler = true;

      await this.notificationService.notifyWholesaleRequestApproved(seller._id.toString(), session);

      await seller.save({ session });
      await wholesaleRequest.save({ session });

      await session.commitTransaction();
      return {
        message: SellerMessage.WholesaleRequestApproved,
      };
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      session.endSession();
    }
  }

  async getWholesaleRequests(queryDto: PaginationDTO) {
    const { limit, skip } = paginationUtils(queryDto);
    const count = await this.wholesaleRequestRepo.model.countDocuments();
    const requests = await this.wholesaleRequestRepo.model
      .find()
      .limit(limit)
      .skip(skip)
      .populate([{ path: "seller" }, { path: "shop" }]);

    return {
      requests,
      count,
    };
  }
  //###################################
  async getSellerPanelInfo(sellerId: string) {
    const { shop } = await this.shopService.getShopInfo(sellerId, OwnerRef.SELLER);
    if (!shop) throw new BadRequestError(ShopMessage.ShopNotFound);

    return {
      shopInfo: shop,
      productCount: await this.getProductCounts(shop._id.toString()),
      logistic: await this.logistic(shop._id.toString()),
      orderStats: await this.orderStats(shop._id.toString()),
      salesStats: await this.salesStats(shop._id.toString()),
      shopRating: await this.shopRating(shop._id.toString()),
    };
  }
  //####################################
  async updateShopShipper(sellerId: string, updateDto: UpdateShopShipmentDTO, type: "activate" | "deactivate") {
    const { shipmentId } = updateDto;

    const shop = await this.shopRepo.model.findOne({ owner: sellerId, ownerRef: OwnerRef.SELLER });
    if (!shop) throw new BadRequestError(ShopMessage.ShopNotFound);

    if (type === "activate") {
      if (shop.shipmentMethod.includes(shipmentId)) throw new BadRequestError(SetShipmentMessage.ShipmentMethodAlreadyActive);

      shop.shipmentMethod.push(shipmentId);
    } else {
      if (!shop.shipmentMethod.includes(shipmentId)) throw new BadRequestError(SetShipmentMessage.ShipmentMethodNotActive);

      shop.shipmentMethod = shop.shipmentMethod.filter((methodId) => methodId !== shipmentId);
    }

    await shop.save();

    return {
      message: CommonMessage.Updated,
    };
  }

  async changeShopChatStatus(sellerId: string) {
    const shop = await this.shopRepo.model.findOne({ owner: sellerId, ownerRef: OwnerRef.SELLER });
    if (!shop) throw new BadRequestError(ShopMessage.ShopNotFound);

    shop.isChatActive = !shop.isChatActive;
    await shop.save();

    return {
      message: CommonMessage.Updated,
    };
  }

  //####################################

  async getItemsCount(sellerId: string) {
    const shop = await this.shopRepo.model.findOne({ owner: sellerId, ownerRef: OwnerRef.SELLER });
    if (!shop) throw new BadRequestError(ShopMessage.ShopNotFound);

    const notificationCount = await this.notificationService.getUnreadNotificationCount(sellerId);
    const ticketCount = await this.ticketService.getUnreadTickerCount(sellerId);
    const chatCount = await this.chatService.getUnreadChatCount(sellerId);
    const orderCount = await this.orderItemRepo.model.countDocuments({ shop: shop._id, status: OrderItemsStatus.Processing });
    return { ticketCount, notificationCount, chatCount, orderCount };
  }

  //####################################
  async createDocumentType(createDto: CreateDocumentTypeDTO) {
    const existDocumentType = await this.documentTypeRepo.model.exists({ title: createDto.title });
    if (existDocumentType) throw new BadRequestError(SellerMessage.DocumentTypeDuplicate);
    const documentType = await this.documentTypeRepo.model.create(createDto);
    return {
      message: CommonMessage.Created,
      documentType,
    };
  }
  //##############################################################
  async getContract(seller: ISeller) {
    let contract;
    contract = await this.sellerContractRepo.model.findOne({ seller: seller._id });
    if (contract) {
      return {
        contract,
      };
    }
    const baseContract = await this.contractRepo.model.findOne();
    if (!baseContract) throw new BadRequestError(ContractMessage.ContractNotFound);

    let national_code;
    let id_number;

    if (seller.businessType === BusinessTypeEnum.REAL) {
      const realSeller = await this.realSellerRepo.model.findOne({ seller: seller._id });
      if (!realSeller) throw new BadRequestError(SellerMessage.SellerNotFound);
      national_code = realSeller.nationalCode;
      id_number = realSeller.nationalCode;
    } else {
      const legalSeller = await this.legalSellerRepo.model.findOne({ seller: seller._id });
      if (!legalSeller) throw new BadRequestError(SellerMessage.SellerNotFound);
      national_code = legalSeller.companyNationalId;
      id_number = legalSeller.companyNationalId;
    }

    const { shop } = await this.shopService.getShopInfo(seller._id.toString(), OwnerRef.SELLER);
    if (!shop.address) throw new BadRequestError(AddressMessage.SellerAddressNotFound);

    const contractContent = this.renderContractTemplate({
      content: baseContract.content,
      seller_name: seller.fullName,
      national_code,
      address: shop.address.address,
      postal_code: shop.address.postalCode,
      date: new Date().toLocaleDateString("fa-IR"),
      id_number,
      email: seller.email,
      phone_number: seller.phoneNumber,
    });

    const contractNumber = `SKC-${randomBytes(5).toString("hex")}-${Date.now().toString().slice(-5)}`;

    contract = await this.sellerContractRepo.model.create({
      seller: seller._id.toString(),
      contractNumber,
      content: contractContent,
    });

    return {
      contract,
    };
  }
  //##############################################################

  async signContract(sellerId: string, contractId: string) {
    if (!isValidObjectId(contractId)) throw new BadRequestError(CommonMessage.NotValidId);
    const contract = await this.sellerContractRepo.model.findOne({ _id: contractId, seller: sellerId });
    if (!contract) throw new BadRequestError(ContractMessage.ContractNotFound);
    if (contract.signed) throw new BadRequestError(ContractMessage.ContractAlreadySigned);

    contract.singedAt = new Date().toLocaleDateString("fa-IR");
    contract.signed = true;
    await contract.save();
    return {
      contract,
    };
  }
  //##############################################################

  async getDocumentTypes() {
    const documentTypes = await this.documentTypeRepo.model.find();
    return { documentTypes };
  }
  //##############################################################

  async uploadSellerDocument(sellerId: string, uploadDto: UploadSellerDocumentDTO) {
    const updatedSellerDocument = await this.sellerDocumentRepo.model.findOneAndUpdate(
      { seller: sellerId, type: uploadDto.documentTypeId },
      { seller: sellerId, type: uploadDto.documentTypeId, docsUrl: uploadDto.docsUrl },
      { new: true, upsert: true },
    );

    return {
      message: CommonMessage.Updated,
      sellerDocument: updatedSellerDocument,
    };
  }
  //##############################################################

  async getSellerDocument(sellerId: string) {
    const sellerDocument = await this.sellerDocumentRepo.model.find({ seller: sellerId }).populate("type");

    return { sellerDocument };
  }
  //##############################################################

  async getSingleSellerDocument(sellerId: string, documentId: string) {
    const sellerDocument = await this.sellerDocumentRepo.model.findOne({ seller: sellerId, _id: documentId }).populate("type");
    if (!sellerDocument) throw new BadRequestError(SellerMessage.SellerDocumentNotFound);

    return {
      sellerDocument,
    };
  }
  //#############
  async updateSellerInfo(type: BusinessTypeEnum, updateDto: RealSellerUpdateDto | LegalSellerUpdateDto, sellerId: string) {
    const session = await startSession();
    session.startTransaction();

    try {
      if (type === BusinessTypeEnum.REAL) {
        const { nationalCode, cardNumber, shebaNumber, ...sellerInfoData } = updateDto as RealSellerUpdateDto;
        //check for duplicate
        await this.checkRealSellerDuplicate(sellerId, nationalCode, cardNumber, shebaNumber, true);
        await this.sellerRepo.model.findByIdAndUpdate(sellerId, { ...sellerInfoData }, { new: true, session });
        await this.realSellerRepo.model.findOneAndUpdate(
          { seller: sellerId },
          { nationalCode, cardNumber, shebaNumber },
          { new: true, session },
        );

        await session.commitTransaction();

        return {
          message: CommonMessage.Updated,
        };
      } else {
        const { IBan, companyName, companyType, companyNationalId, companyEconomicNumber, ...sellerInfo } =
          updateDto as LegalSellerUpdateDto;
        //check for duplicate
        await this.checkCompanyDuplicate(sellerId, companyName, companyNationalId, companyEconomicNumber, IBan, true);
        await this.sellerRepo.model.findByIdAndUpdate(sellerId, { ...sellerInfo }, { new: true, session });
        await this.legalSellerRepo.model.findOneAndUpdate(
          { seller: sellerId },
          { companyName, companyNationalId, companyEconomicNumber, IBan, companyType },
          { new: true, session },
        );

        await session.commitTransaction();
        return {
          message: CommonMessage.Updated,
        };
      }
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      await session.endSession();
    }
  }

  //#######################

  async completeRegistrationReal(sellerId: string, completeRealDto: CompleteRespirationRealDTO) {
    const session = await startSession();
    session.startTransaction();

    try {
      const shop = await this.shopRepo.model.findOne({ owner: sellerId, ownerRef: OwnerRef.SELLER });
      if (!shop) throw new BadRequestError(ShopMessage.ShopNotFound);

      const { nationalCode, cardNumber, shebaNumber, ...sellerInfo } = completeRealDto;

      const existEmail = await this.sellerRepo.model.exists({ _id: { $ne: sellerId }, email: sellerInfo.email }).session(session);
      if (existEmail) throw new BadRequestError(AuthMessage.EmailExists);

      const seller = await this.sellerRepo.model.findByIdAndUpdate(
        sellerId,
        { ...sellerInfo, businessType: sellerInfo.business_type, isRegisterCompleted: true },
        { new: true, session },
      );

      const existShopName = await this.shopRepo.model.find({ shopName: completeRealDto.companyName });
      if (existShopName.length) throw new BadRequestError(ShopMessage.ShopNameExist);

      shop.shopName = completeRealDto.companyName;
      await shop.save();

      await this.checkRealSellerDuplicate(sellerId, nationalCode, cardNumber, shebaNumber);

      const realSeller = await this.realSellerRepo.model.create([{ seller: sellerId, nationalCode, cardNumber, shebaNumber }], { session });

      await this.sellerStatusRepo.model.create([{ seller: sellerId }], { session });

      await session.commitTransaction();
      return {
        message: CommonMessage.Updated,
        seller,
        realSeller: realSeller[0],
      };
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      await session.endSession();
    }
  }

  //#######################
  async completeRegistrationLegal(sellerId: string, completeLegalDto: CompleteRespirationLegalDTO) {
    const session = await startSession();
    session.startTransaction();
    try {
      const shop = await this.shopRepo.model.findOne({ owner: sellerId, ownerRef: OwnerRef.SELLER });
      if (!shop) throw new BadRequestError(ShopMessage.ShopNotFound);

      const { IBan, companyName, companyType, companyNationalId, companyEconomicNumber, ...sellerInfo } = completeLegalDto;

      const existEmail = await this.sellerRepo.model.exists({ _id: { $ne: sellerId }, email: sellerInfo.email });
      if (existEmail) throw new BadRequestError(AuthMessage.EmailExists);

      const seller = await this.sellerRepo.model.findByIdAndUpdate(
        sellerId,
        { ...sellerInfo, businessType: sellerInfo.business_type, isRegisterCompleted: true },
        { new: true, session },
      );

      const existShopName = await this.shopRepo.model.find({ shopName: completeLegalDto.companyName });
      if (existShopName.length) throw new BadRequestError(ShopMessage.ShopNameExist);

      shop.shopName = completeLegalDto.companyName;
      await shop.save();

      await this.checkCompanyDuplicate(companyName, companyNationalId, companyEconomicNumber, IBan);

      const legalSeller = await this.legalSellerRepo.model.create(
        [{ seller: sellerId, IBan, companyName, companyType, companyNationalId, companyEconomicNumber }],
        { session },
      );

      await this.sellerStatusRepo.model.create([{ seller: sellerId }], { session });

      await session.commitTransaction();
      return {
        message: CommonMessage.Updated,
        seller,
        legal: legalSeller[0],
      };
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      await session.endSession();
    }
  }

  //#######################
  async getSellerProfileInfo(sellerId: string) {
    const seller = await this.sellerRepo.model.findById(sellerId);
    if (!seller) throw new BadRequestError(SellerMessage.SellerNotFound);

    if (seller.businessType === BusinessTypeEnum.REAL) {
      const realSeller = await this.realSellerRepo.model.findOne({ seller: sellerId });
      return {
        baseSeller: seller,
        realSeller,
      };
    }

    const legalSeller = await this.legalSellerRepo.model.findOne({ seller: sellerId });

    return {
      baseSeller: seller,
      legalSeller,
    };
  }

  //#######################
  async requestWholesale(sellerId: string) {
    const shop = await this.shopRepo.model.findOne({ owner: sellerId, ownerRef: OwnerRef.SELLER });
    if (!shop) throw new BadRequestError(ShopMessage.ShopNotFound);

    const existRequest = await this.wholesaleRequestRepo.model.exists({ seller: sellerId, shop: shop._id });
    if (existRequest) throw new BadRequestError(SellerMessage.WholesaleRequestPending);

    const wholesaleRequest = await this.wholesaleRequestRepo.model.create({ seller: sellerId, shop: shop._id });

    return {
      message: SellerMessage.WholesaleRequestCreated,
      request: wholesaleRequest,
    };
  }

  //#######################
  async getSellerStatus(sellerId: string) {
    let isSellerActive = false;
    const status = await this.sellerStatusRepo.model.findOne({ seller: sellerId }).lean();
    // if (status?.banned) throw new BadRequestError("اکانت شما از دسترس خارج شده است. با پشتیبانی تماس بگیرید.")
    if (status?.contract && status?.register && status?.document && status?.learning) {
      isSellerActive = true;
    }
    // if (!status) throw new BadRequestError(SellerMessage.StatusNotFound);
    return {
      status,
      isSellerActive,
    };
  }

  //#######################
  async getAllSellerForReport() {
    return await this.sellerRepo.getAllSellerForReport();
  }

  //#######################
  async getWholesaleRequestCount() {
    return await this.wholesaleRequestRepo.getWholesaleRequestCount();
  }

  /** helper methods */
  private async getProductCounts(shopId: string) {
    return this.productRepo.model.countDocuments({ shop: shopId });
  }

  private async logistic(shopId: string) {
    const oneWeekAgo = new Date();
    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);

    const shopCategories = await this.productRepo.model.distinct("category", { shop: shopId });
    const rivalProductsCount = await this.productRepo.model.countDocuments({
      shop: { $ne: shopId },
      category: { $in: shopCategories },
    });

    const returnedLastWeekCount = await this.orderItemRepo.model.aggregate([
      {
        $match: {
          shop: shopId,
          "shipmentItems.returned_quantity": { $gt: 0 },
          createdAt: { $gte: oneWeekAgo },
        },
      },
      {
        $group: { _id: null, totalReturns: { $sum: "$shipmentItems.returned_quantity" } },
      },
    ]);
    const returnedLastWeek = returnedLastWeekCount[0]?.totalReturns || 0;

    return {
      availableProducts: await this.productVariantRepo.model.countDocuments({ stock: { $gte: 5 }, shop: shopId }),
      outOfStockProducts: await this.productVariantRepo.model.countDocuments({ stock: 0, shop: shopId }),
      restockingProducts: await this.productVariantRepo.model.countDocuments({ stock: { $lte: 5, $gt: 0 }, shop: shopId }),
      returnedLastWeek,
      rivalProducts: rivalProductsCount,
    };
  }

  private async orderStats(shopId: string) {
    const orderCount = await this.orderItemRepo.model.countDocuments({ shop: shopId });

    const completedOrdersCount = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      status: OrderItemsStatus.Delivered,
    });

    const startOfWeek = new Date();
    startOfWeek.setDate(startOfWeek.getDate() - startOfWeek.getDay());
    const ordersThisWeek = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      createdAt: { $gte: startOfWeek },
    });

    const startOfToday = new Date();
    startOfToday.setHours(0, 0, 0, 0);
    const ordersToday = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      createdAt: { $gte: startOfToday },
    });

    const unapprovedOrders = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      status: OrderItemsStatus.Processing,
    });

    const shippedOrders = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      status: OrderItemsStatus.Shipped,
    });

    const delayedOrders = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      postingDate: { $lt: new Date() },
      status: { $ne: OrderItemsStatus.Delivered },
    });

    return {
      orderCount,
      completedOrdersCount,
      ordersThisWeek,
      ordersToday,
      unapprovedOrders,
      shippedOrders,
      delayedOrders,
    };
  }

  private async salesStats(shopId: string) {
    const startOfWeek = new Date();
    startOfWeek.setDate(startOfWeek.getDate() - startOfWeek.getDay());
    const startOfLastWeek = new Date(startOfWeek);
    startOfLastWeek.setDate(startOfWeek.getDate() - 7);
    const startOfMonth = new Date();
    startOfMonth.setDate(1);

    const totalSale = await this.orderItemRepo.model.aggregate([
      { $match: { shop: shopId, status: OrderItemsStatus.Delivered } },
      { $group: { _id: null, total: { $sum: "$totalSellingPrice" } } },
    ]);
    const totalSaleAmount = totalSale[0]?.total || 0;

    const weeklySale = await this.orderItemRepo.model.aggregate([
      {
        $match: {
          shop: shopId,
          status: OrderItemsStatus.Delivered,
          createdAt: { $gte: startOfWeek },
        },
      },
      { $group: { _id: null, total: { $sum: "$totalSellingPrice" } } },
    ]);
    const weeklySaleAmount = weeklySale[0]?.total || 0;

    const previousWeekSale = await this.orderItemRepo.model.aggregate([
      {
        $match: {
          shop: shopId,
          status: OrderItemsStatus.Delivered,
          createdAt: { $gte: startOfLastWeek, $lt: startOfWeek },
        },
      },
      { $group: { _id: null, total: { $sum: "$totalSellingPrice" } } },
    ]);
    const previousWeekSaleAmount = previousWeekSale[0]?.total || 0;

    const monthlySale = await this.orderItemRepo.model.aggregate([
      {
        $match: {
          shop: shopId,
          status: OrderItemsStatus.Delivered,
          createdAt: { $gte: startOfMonth },
        },
      },
      { $group: { _id: null, total: { $sum: "$totalSellingPrice" } } },
    ]);
    const monthlySaleAmount = monthlySale[0]?.total || 0;

    const salesCountWeekly = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      status: OrderItemsStatus.Delivered,
      createdAt: { $gte: startOfWeek },
    });

    const salesCountPreviousWeek = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      status: OrderItemsStatus.Delivered,
      createdAt: { $gte: startOfLastWeek, $lt: startOfWeek },
    });

    const salesCountPreviousMonth = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      status: OrderItemsStatus.Delivered,
      createdAt: {
        $gte: new Date(new Date().setDate(0)),
        $lt: startOfMonth,
      },
    });

    return {
      totalSale: totalSaleAmount,
      weeklySale: weeklySaleAmount,
      previousWeekSale: previousWeekSaleAmount,
      monthlySale: monthlySaleAmount,
      salesCountWeekly,
      salesCountPreviousWeek,
      salesCountPreviousMonth,
    };
  }

  private async shopRating(shopId: string) {
    const shop = await this.shopRepo.model.findById(shopId);
    if (!shop) throw new BadRequestError(ShopMessage.ShopNotFound);

    const oneMonthAgo = new Date();
    oneMonthAgo.setMonth(oneMonthAgo.getMonth() - 1);

    const ratingData = await this.commentRepo.model.aggregate([
      {
        $match: {
          product: { $in: await this.productRepo.model.distinct("_id", { shop: shopId }) },
          rate: { $exists: true },
        },
      },
      {
        $group: {
          _id: null,
          totalRate: { $sum: "$rate" },
          totalCount: { $sum: 1 },
        },
      },
    ]);

    const totalRate = ratingData[0]?.totalRate || 0;
    const totalCount = ratingData[0]?.totalCount || 0;

    const onTimeShipments = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      status: OrderItemsStatus.Delivered,
      postingDate: { $exists: true, $ne: null },
      createdAt: { $gte: oneMonthAgo },
    });

    const returnsCount = await this.orderItemRepo.model.aggregate([
      {
        $match: {
          shop: shopId,
          "shipmentItems.returned_quantity": { $gt: 0 },
          createdAt: { $gte: oneMonthAgo },
        },
      },
      {
        $group: { _id: null, totalReturns: { $sum: "$shipmentItems.returned_quantity" } },
      },
    ]);
    const totalReturns = returnsCount[0]?.totalReturns || 0;

    const cancellationsCount = await this.orderItemRepo.model.countDocuments({
      shop: shopId,
      status: OrderItemsStatus.cancelled_shop,
      createdAt: { $gte: oneMonthAgo },
    });

    shop!.rate.cancel = cancellationsCount;
    shop!.rate.onTimeShip = onTimeShipments;
    shop!.rate.returns = totalReturns;
    shop!.rate.totalCount = totalCount;
    shop!.rate.totalRate = totalRate;

    await shop!.save();

    return {
      totalRate,
      totalCount,
      onTimeShip: onTimeShipments,
      returns: totalReturns,
      cancel: cancellationsCount,
    };
  }

  private async checkCompanyDuplicate(
    sellerId: string,
    companyName?: string,
    companyNationalId?: string,
    companyEconomicNumber?: string,
    IBan?: string,
    update: boolean = false,
  ) {
    const query: FilterQuery<ILegalSeller> = {
      $or: [{ companyName }, { companyNationalId }, { companyEconomicNumber }, { IBan }],
    };

    if (update) query.seller = { $ne: sellerId };

    const existCompany = await this.legalSellerRepo.model.findOne(query);
    if (existCompany) throw new BadRequestError(SellerMessage.CompanyDuplicate);

    return true;
  }

  private async checkRealSellerDuplicate(
    sellerId: string,
    nationalCode?: string,
    cardNumber?: string,
    shebaNumber?: string,
    update: boolean = false,
  ) {
    const query: FilterQuery<IRealSeller> = {
      $or: [{ nationalCode }, { cardNumber }, { shebaNumber }],
    };

    if (update) query.seller = { $ne: sellerId };

    const existRealSeller = await this.realSellerRepo.model.findOne(query);

    if (existRealSeller) throw new BadRequestError(SellerMessage.RealSellerDuplicate);

    return true;
  }

  private renderContractTemplate(data: ContractType): string {
    return contractTemplate(data);
  }
}

export { SellerService };