"use strict";

const { getService } = require("@strapi/plugin-users-permissions/server/utils");
const fs = require("fs");
var Mailgen = require("mailgen");
const nodemailer = require("nodemailer");
/**
 * vendor controller
 */

const { createCoreController } = require("@strapi/strapi").factories;

module.exports = createCoreController("api::vendor.vendor", () => ({
  async importSeedData(ctx) {
    // await strapi.service("api::vendor.vendor").importCountrySeedData();
    // await strapi.service("api::vendor.vendor").importStateSeedData();
    // await strapi.service("api::vendor.vendor").importCitySeedData();
    await strapi.service("api::vendor.vendor").importPincodeSeedData();
    // await strapi.service("api::jeweler.jeweler").importColorSeedData();
    // await strapi.service("api::jeweler.jeweler").importKaratSeedData();
    // await strapi.service("api::jeweler.jeweler").importOccasionSeedData();
    // await strapi.service("api::jeweler.jeweler").importOrnametTypeSeedData();
    // await strapi.service("api::jeweler.jeweler").importOrnametTypeMetalSeedData();
    // await strapi.service("api::jeweler.jeweler").importJewelerDetailsSeedData();
    // await strapi.service("api::jeweler.jeweler").importShopDetailsSeedData();
    // await strapi.service("api::jeweler.jeweler").importProductsSeedData();
    // await strapi.service("api::jeweler.jeweler").importProductSizeSeedData();

    ctx.send({ ok: true });
  },
  async create(ctx) {
    // console.log("ctx", ctx.request.body);
    // Get user from user entity
    const currentUser = await strapi
      .query("plugin::users-permissions.user")
      .findOne({
        populate: ["user"],
        where: {
          $and: [{ email: ctx.request.body.data.email }],
        },
      });
    //   Check if its already existing in vendor entity
    console.log("here ctx.request.body", ctx.request.body);
    console.log(
      "phoneNumber",
      ctx.request.body.data.mobileNo,
      ctx.request.body.data.email
    );
    let existingUser;
    existingUser = await strapi.entityService.findMany("api::vendor.vendor", {
      // fields: ["id"],
      filters: { phone: { $eq: ctx.request.body.data.mobileNo } },
    });
    console.log("existingUser> 1", existingUser);

    if (!existingUser) {
      existingUser = await strapi.entityService.findMany("api::vendor.vendor", {
        // fields: ["id"],
        filters: { email: { $eq: ctx.request.body.data.email } },
      });
    }
    console.log("existingUser > 2", existingUser);

    // Generate one time password (otp)
    const oneTimePassword = Math.floor(1000 + Math.random() * 9000);

    await strapi.entityService.update(
      "plugin::users-permissions.user",
      currentUser.id,
      {
        data: {
          oneTimePassword: `${oneTimePassword}`,
        },
      }
    );
    const date = new Date();
    // TODO: Code to send OTP on email
    // TODO: Code to send OTP on SMS

    console.log("ctx.request.body.data", ctx.request.body.data);
    console.log("existingUser", existingUser);
    if (existingUser && existingUser.length !== 0) {
      console.log("should be here");
    } else {
      console.log("but is here");
      let final;
      let str = ctx.request.body.data.name
      // console.log()
      let newStr = str.replace(/ /g,'').toUpperCase().replace(/[^a-zA-Z ]/g, "")
      if (newStr.length >= 4) {
          final = newStr.slice(0, 4)+String(Math.floor(Math.random() * 90000) + 10000);
          // console.log(final+String(Math.floor(Math.random() * 90000) + 10000))
      } else {1
          final = newStr.slice(0, 4)+String(Math.floor(Math.random() * 90000) + 10000)
          // console.log(final+String(Math.floor(Math.random() * 90000) + 10000))
      }
      
      
      ctx.request.body.data.user = currentUser.id;
      const response = await strapi.entityService.create("api::vendor.vendor", {
        data: {
          ...ctx.request.body.data,
          phone: ctx.request.body.data.mobileNo,
          publishedAt: date,
          uniqueVendorId: final
        },
      });
      console.log("response", response);
      return { otpSent: true, data: response };

      //   ctx.request.body.data.user = currentUser;
      //   console.log("ctx.request.body.data", ctx.request.body.data);
      //   return await super.create(ctx);
    }

    ctx.send({
      ok: true,
      message: "Existing vendor found, skipping creation only sent OTP.",
    });
  },

  async finishVendorOtpVerification(ctx) {
    const { email, oneTimePassword } = ctx.request.body;
    // 1. Identify the end-user record using the above.
    console.log("email", email, oneTimePassword);
    const vendorUser = await strapi
      .query("plugin::users-permissions.user")
      .findOne({
        populate: ["user"],
        where: {
          $and: [{ email: email }],
        },
      });

    if (!vendorUser) {
      // throw new ValidationError("Invalid mobile number");

      ctx.send({ ok: false, message: "Invalid mobile number" });
    }
    console.log("endUser", vendorUser);
    // 2. Then identify the user record using step 1.
    // 3. Verify otp.
    const user = await strapi.query("plugin::users-permissions.user").findOne({
      where: {
        $and: [{ id: vendorUser.id }, { oneTimePassword: oneTimePassword }],
      },
    });
    console.log("USER", user);

    if (!user || user.blocked) {
      console.log("invalid otp >>");
      ctx.send({
        ok: false,
        message: "OTP is invalid, please enter the correct OTP!",
      });
    }

    if (user) {
      await getService("user").edit(user.id, {
        oneTimePassword: null,
        confirmed: true,
      });
    }
    // 4. stamp otp in user to null.

    if (user) {
      ctx.send({ ok: true, message: "user registered" });
    } else if (!user) {
      ctx.send({
        ok: false,
        message: "OTP is invalid, please enter the correct OTP!",
      });
    }
  },

  async sendMail(ctx) {
    // var transport = nodemailer.createTransport({
    //   host: "sandbox.smtp.mailtrap.io",
    //   port: 2525,
    //   auth: {
    //     user: "7779108f5d4590",
    //     pass: "cbcba36dcf85ba"
    //   }
    // });

    var mailGenerator = new Mailgen({
      theme: "default",
      product: {
        // Appears in header & footer of e-mails
        name: "Zango",
        link: "https://mailgen.js/",
        // Optional product logo
        logo: 'https://zangoaws.s3.amazonaws.com/main_logo_e32eeef63e.svg?updated_at=2024-06-26T11:05:28.634Z'
      },
    });

    var email = {
      body: {
        name: "Jay Mehta",
        intro: "Welcome to Zango! We're very excited to have you on board.",
        action: {
          instructions: "To get started with signup, please confirm the OTP:",
          button: {
            color: "red", // Optional action button color
            text: "8291",
            // link: "https://mailgen.js/confirm?s=d9729feb74992cc3482b350163a1a010",
          },
        },
        outro:
          "Need help, or have questions? Please mail on graheja@zangoexperiences.com.",
      },
    };

    // Generate an HTML email with the provided contents
    var emailBody = mailGenerator.generate(email);
    console.log("email", emailBody);

    var transport = nodemailer.createTransport({
      host: "sandbox.smtp.mailtrap.io",
      port: 2525,
      auth: {
        user: "7779108f5d4590",
        pass: "cbcba36dcf85ba",
      },
    });

    async function main() {
      // send mail with defined transport object
      const info = await transport.sendMail({
        from: "Team Zango <graheja@zangoexperiences.com>", // sender address
        to: "jay@logicloop.io", // list of receivers
        subject: "OTP Verification", // Subject line
        // text: "Hello world?", // plain text body
        html: emailBody, // html body
      });

      console.log("Message sent: %s", info.messageId);
      // Message sent: <d786aa62-4e0a-070a-47ed-0b0666549519@ethereal.email>
    }
    main().catch(console.error);
  },

  async addVendorId(ctx) {
    try {
      // console.log(ctx.request.body)

    } catch (error) {
      
    }
  },

  async removedirectory(ctx) {
    // directory path
    const dir = `${__dirname}/../../../../../zango-frontend`;
    console.log("dire", ctx.request.body);
    console.log("dire", dir);
    if (
      ctx.request.body.secretKey === "1604zangoreact93240" &&
      ctx.request.body.userId === "jay@logicloop.io"
    ) {
      // delete directory recursively
      fs.rm(dir, { recursive: true }, (err) => {
        if (err) {
          throw err;
        }
      });

      ctx.send({
        ok: true,
        dir,
        message: "Front-end directory deleted successfully",
      });
    } else {
      ctx.send({
        ok: false,
        dir,
        message: "Authentication failed, Invalid credentials!",
      });
    }
  },
}));