"use strict";

/**
 * vendor service
 */

const { createCoreService } = require("@strapi/strapi").factories;
const { factories } = require("@strapi/strapi");
const fs = require("fs");
const { parse } = require("csv-parse");

module.exports = createCoreService(
  "api::vendor.vendor",
  ({ strapi: Strapi }) => ({
    async importCountrySeedData() {
      const countryData = await fs.promises.readFile(
        `${__dirname}/../seed-data/country.json`,
        "utf8"
      );
      const countries = JSON.parse(countryData);
      // console.log(countries);

      // get rid of all existing countries.
      const deletedCnt = await strapi.db
        .query("api::master-country.master-country")
        .deleteMany({ where: {} });
      // console.log(`Bulk deleted existing countries, got rid of: ${deletedCnt.count} country records.`);

      // re-create them again.
      for (let i = 0; i < countries.length; i++) {
        const country = countries[i];
        //   console.log(`Attempting to create country: `, country);
        await strapi.entityService.create(
          "api::master-country.master-country",
          {
            data: {
              name: country.name,
            },
          }
        );
      }
    },

    async importStateSeedData() {
      const stateData = await fs.promises.readFile(
        `${__dirname}/../seed-data/state.json`,
        "utf8"
      );
      const states = JSON.parse(stateData);
      // console.log(states);

      // get rid of all existing states.
      const deletedCnt = await strapi.db
        .query("api::master-state.master-state")
        .deleteMany({ where: {} });
      // console.log(`Bulk deleted existing states, got rid of: ${deletedCnt.count} state records.`);

      // re-create them again.
      for (let i = 0; i < states.length; i++) {
        const state = states[i];
        const matchingCountries = await strapi.entityService.findMany(
          "api::master-country.master-country",
          {
            fields: ["id"],
            filters: { name: state.country },
          }
        );
        let statefinal;
        if (!matchingCountries || matchingCountries.length === 0) {
          console.log(
            `Unable to resolve a country with name ${
              state.country
            }, skipping creation of state ${JSON.stringify(state)}`
          );
        } else {
          //   console.log(`Attempting to create state: `, state);
          statefinal = await strapi.entityService.create(
            "api::master-state.master-state",
            {
              data: {
                name: state.name,
                masterCountry: matchingCountries[0].id,
              },
            }
          );
          //   console.log("state", statefinal);
        }
      }
    },

    async importCitySeedData() {
      const cityData = await fs.promises.readFile(
        `${__dirname}/../seed-data/city.json`,
        "utf8"
      );
      const cities = JSON.parse(cityData);
      // console.log(citys);

      // get rid of all existing citys.
      const deletedCnt = await strapi.db
        .query("api::master-city.master-city")
        .deleteMany({ where: {} });
      // console.log(`Bulk deleted existing citys, got rid of: ${deletedCnt.count} city records.`);

      // re-create them again.
      for (let i = 0; i < cities.length; i++) {
        const city = cities[i];
        const matchingStates = await strapi.entityService.findMany(
          "api::master-state.master-state",
          {
            fields: ["id"],
            filters: { name: city.state },
          }
        );

        if (!matchingStates || matchingStates.length === 0) {
          console.log(
            `Unable to resolve a state with name ${
              city.state
            }, skipping creation of city ${JSON.stringify(city)}`
          );
        } else {
          //   console.log(`Attempting to create city: `, city);
          await strapi.entityService.create("api::master-city.master-city", {
            data: {
              name: city.name,
              masterState: matchingStates[0].id,
            },
          });
        }
      }
    },

    async importPincodeSeedData() {
      // const pincodeData = await fs.readFile(`${__dirname}/../seed-data/StateCityPinMasterSeeder.csv`);

      // const records = parse(fileContent, );

      // const pincodes = parse(pincodeData,{columns: true});
      // console.log(citys);
      let pincodeData = [];

      const deletedCnt = await strapi.db
        .query("api::master-pincode.master-pincode")
        .deleteMany({ where: {} });
      const deletedStateCnt = await strapi.db
        .query("api::master-state.master-state")
        .deleteMany({ where: {} });
      const deletedCityCnt = await strapi.db
        .query("api::master-city.master-city")
        .deleteMany({ where: {} });

      // const pincodeData = fs.createReadStream(`${__dirname}/../seed-data/StateCityPinMasterSeeder.csv`).pipe(parse({ delimiter: ",", from_line: 1 }));
      fs.createReadStream(
        `${__dirname}/../seed-data/StateCityPinMasterSeeder.csv`
      )
        .pipe(parse({}))
        .on("data", (data) => {
          //   console.log("data", data);
          pincodeData.push(data);
        })
        .on("end", () => {
          resolveSeedData(pincodeData);
        });

      const resolveSeedData = async (seedData) => {
        console.log("pincode data", seedData);
        for (let i = 0; i < seedData.length; i++) {
          const singleData = seedData[i];
          const pincode = singleData[0];
          const city = singleData[1];
          const state = singleData[2];

          let stateId;
          let cityId;
          console.log("pincode", pincode);
          console.log("city", city);
          console.log("state", state);
          const resolveCountry = await strapi
            .query("api::master-country.master-country")
            .findOne({
              where: {
                $and: [{ name: "India" }],
              },
            });
          console.log("resolveCountry", resolveCountry);
          let resolveState = await strapi
            .query("api::master-state.master-state")
            .findOne({
              where: {
                $and: [{ name: state }],
              },
            });
          console.log("resolveState", resolveState);

          if (resolveState == null) {
            resolveState = await strapi.entityService.create(
              "api::master-state.master-state",
              {
                data: {
                  name: state,
                  masterCountry: resolveCountry.id,
                },
              }
            );
          console.log("resolveState", resolveState);

            stateId = resolveState.id;
          } else {
            stateId = resolveState.id;
          }
          let resolveCity = await strapi
            .query("api::master-city.master-city")
            .findOne({
              where: {
                $and: [{ name: city, masterState: stateId }],
              },
            });
            console.log("resolveCity", resolveCity);
          if (resolveCity == null) {
            resolveCity = await strapi.entityService.create(
              "api::master-city.master-city",
              {
                data: {
                  name: city,
                  masterState: stateId,
                },
              }
            );
            console.log("resolveCity", resolveCity);

            cityId = resolveCity.id;
          } else {
            cityId = resolveCity.id;
          }
          let resolvePincode = await strapi
            .query("api::master-pincode.master-pincode")
            .findOne({
              where: {
                $and: [{ name: state }],
              },
            });

          let currentCity = await strapi
            .query("api::master-city.master-city")
            .findOne({
              where: {
                $and: [{ name: city }],
              },
            });

          if (resolvePincode == null) {
            resolvePincode = await strapi.entityService.create(
              "api::master-pincode.master-pincode",
              {
                data: {
                  name: pincode,
                  masterCity: currentCity.id,
                },
              }
            );
          }
        }
      };
    },
  })
);