const express = require("express");
const bodyParser = require("body-parser");
const cookieParser = require("cookie-parser");
const { setupFdk } = require("fdk-extension-javascript");
const { RedisStorage } = require("fdk-extension-javascript/storage"); //RedisStorage class is provided by default. If you have implemented custom storage class, use <YourCustomStorageClass> here.
const Redis = require("ioredis");

const app = express();
app.use(cookieParser("ext.session"));
app.use(bodyParser.json({ limit: "2mb" }));

const redis = new Redis();

let extensionHandler = {
  auth: async function (data) {
    console.log("called auth callback");
  },

  uninstall: async function (data) {
    console.log("called uninstall callback");
  },
};

let fdkClient = setupFdk({
  api_key: "<API_KEY>", // API Key of an extension for authentication.
  api_secret: "<API_SECRET>", // API Secret of an extension for authentication.
  base_url: baseUrl, // optional. Base URL for extension.
  scopes: ["company/products"], // optional. An array of scopes indicating the specific permissions needed for an extension.
  callbacks: extensionHandler, // The callback function to handle extension-related tasks.
  storage: new RedisStorage(redis), // An instance of storage (e.g., RedisStorage) for data storage.
  access_mode: "offline", // Access mode of an extension. It can be `online` or `offline`.
  cluster: "https://api.fyndx0.de", // optional. The API url of the Fynd Platform cluster.
});

let router = app.express.Router();
const handlers = fdkClient.routerHandlers; // Functions that constains implementaion of OAuth

router.get("/fp/install", async (req, res, next) => {
    const { redirectUrl, fdkSession } = await handlers.fpInstall(
        req.query.company_id,
        req.query.application_id, // optional
        fdkClient.extension
    );
    // Return redirect url obtained in fpInstall call
    // Return fdk session (for example in cookies or jwt token or any other form )
    /*res.cookie(compCookieName, fdkSession.id, {
        secure: true,
        httpOnly: true,
        expires: fdkSession.expires,
        signed: true,
        sameSite: "None",
     });
    res.redirect(redirectUrl); */
});


router.get("/fp/auth", async (req, res, next) => {
    let sessionId = session_id; // Get the session id from cookies or jwt token or any other form
    req.fdkSession = await redis.get(sessionId); // Attach session to request object
    req.extension = fdkClient.extension; // Attach extension to request object
    const { redirectUrl, fdkSession } = await handlers.fpAuth(
        reqObj,
        req.query.state,
        req.query.code,
        fdkClient.extension,
        sessionId
    );
    // Return redirect url obtained in fpInstall call
    // Return fdk session (for example in cookies or jwt token or any other form )
    /*res.cookie(compCookieName, fdkSession.id, {
        secure: true,
        httpOnly: true,
        expires: fdkSession.expires,
        signed: true,
        sameSite: "None",
    });
    res.redirect(redirectUrl); */
});

router.post("/fp/auto_install", async (req, res, next) => {
    await handlers.fpAutoInstall(
        reqObj,
        req.body.company_id,
        req.body.code,
        fdkClient.extension
    );
    res.json({ message: "success" });
});

router.post("/fp/uninstall", async (req, res, next) => {
    await handlers.fpUninstall(
        reqObj,
        req.body.company_id,
        fdkClient.extension
    );
    res.json({ success: true });
});

app.use(router);
app.listen(3000);

fdkClient.platformApiRoutes.get("/test/routes", async (req, res, next) => {
    req.fdkSession = await fdkClient.getSessionData(sessionId); // Get the session id from cookies or jwt token or any other form 
    if (!req.fdkSession) { // Authorize for valid request
    return res.status(401).json({ message: "User is unauthorized" });
    }
    
    let platformClient = await fdkClient.getPlatformClient(company_id, req.fdkSession)
    let data = await platformClient.lead.getTickets();
    res.json(data);
});

app.use(fdkClient.platformApiRoutes);

function backgroundHandler(companyId) {
  let fdkSession = await fdkClient.getSessionData(sessionId); // Get the session id from cookies or jwt token or any other form 

  let platformClient = await fdkClient.getPlatformClient(company_id, req.fdkSession);
  let data = await platformClient.lead.getTickets();
  // Some business logic here
  res.send({ success: true });
}

fdkClient.applicationRouter.get("/test/routes", async (req, res, next) => {
    const user = await fdkClient.getUserData(req.headers["x-user-data"]); 
    const { application, applicationConfig, applicationClient } =
    await fdkClient.getApplicationConfig(
        req.headers["x-application-data"],
        fdkClient.extension
    );
    let data = await applicationClient.lead.getTickets();
    res.send({ success: true });
});
app.use(fdkClient.applicationRouter);

fdkClient.partnerApiRoutes.get("/test/routes", async (req, res, next) => {
  try {
    req.fdkSession = await fdkClient.getSessionData(sessionId); // Get the session id from cookies or jwt token or any other form 
    if (!req.fdkSession) { // Authorize for valid request
      return res.status(401).json({ message: "User is unauthorized" });
    }
    let partnerClient = await fdkClient.getPartnerClient(organizarion_id, req.fdkSession)
    let data = await partnerClient.theme.getThemes();    
    res.json(data);
  } catch (error) {
    console.error(error);
    next(error);
  }
});

app.use(fdkClient.partnerApiRoutes);

let fdkClient = setupFdk({
  api_key: "<API_KEY>",
  api_secret: "<API_SECRET>",
  base_url: baseUrl, // this is optional
  scopes: ["company/products"], // this is optional
  callbacks: extensionHandler,
  storage: new RedisStorage(redis),
  access_mode: "offline",
  webhook_config: {
    api_path: "/api/v1/webhooks", // API endpoint to process webhooks event.
    notification_email: "test@abc.com", // Email address for webhook related notifications.
    subscribe_on_install: false, // optional. Whether to auto subscribe to all webhooks on extension installation. It can be true or false.
    subscribed_saleschannel: 'specific', // optional. If `specific` then you have to manually subscribe to sales channel/website level events for individual sales channels. Value can be `all` or `optional`.
    event_map: { // required
      'company/brand/create': { // Event topic name follows {category}/{name}/{type} structure. Refer event payload to get 'category', 'name' and 'type' for required events
        version: '1', // API version of specified event
        handler: handleBrandCreate // A handler function when specified event occures
      },
      'company/location/update': {
        version: '1',
        handler: handleLocationUpdate
      },
      'application/coupon/create': {
        version: '1',
        handler: handleCouponCreate
      }
    }
  },
  debug: true // optional. Enables debug logs if `true`. Default `false`
});

app.post('/api/v1/webhooks', async (req, res, next) => {
  try {
    await fdkClient.webhookRegistry.processWebhook(req);
    return res.status(200).json({"success": true});
  }
  catch(err) {
    logger.error(err);
    return res.status(500).json({"success": false});
  }
});