Proxy

require('dotenv').config();
const express = require('express');

const cors = require('cors');
const { createProxyMiddleware } = require('http-proxy-middleware');

const app = express();
const apiConfigCache = {};


const allowedOrigins = process.env.ALLOWED_ORIGINS.split(',');
const allowedOriginDev = new RegExp(process.env.ALLOWED_ORIGIN_DEV);
let allowedSageActiveEnvs;
let isInternal = false;

const corsOptions = {
  origin: function (origin, callback) {
    if (allowedOrigins.includes(origin) || (allowedOriginDev && allowedOriginDev.test(origin))) {
      callback(null, true);
    } else {
      callback(new Error(`${origin} not allowed by CORS Proxy policy`));
    }
  }
};

app.use(cors(corsOptions));
app.options('*', cors(corsOptions));

//Allows the front to retrieve environments info
app.get('/api/environments', (req, res) => {
  isInternal = req.headers['x-frontend-url'].includes('/internal/');
  allowedSageActiveEnvs = isInternal ? process.env.ALLOWED_ENVS_INTERNAL.split(',') : process.env.ALLOWED_ENVS.split(',');

  const filteredSbcAuthEnvBySageActiveEnv = Object.keys(sbcAuthEnvBySageActiveEnv)
    .filter(key => allowedSageActiveEnvs.includes(key))
    .reduce((obj, key) => {
      obj[key] = sbcAuthEnvBySageActiveEnv[key];
      return obj;
    }, {});

  const filteredSbcAuthConfigBySageActiveEnvs = Object.keys(sbcAuthConfigBySageActiveEnvs)
    .filter(key => Object.values(filteredSbcAuthEnvBySageActiveEnv).includes(key))
    .reduce((obj, key) => {
      obj[key] = sbcAuthConfigBySageActiveEnvs[key];
      return obj;
    }, {});

  res.json({ 
    allowedSageActiveEnvs: allowedSageActiveEnvs,
    sbcAuthConfigBySageActiveEnvs: filteredSbcAuthConfigBySageActiveEnvs,
    sbcAuthEnvBySageActiveEnv: filteredSbcAuthEnvBySageActiveEnv
  });
});

function determineApiTarget(env) {
  if (!allowedSageActiveEnvs.includes('*') && !allowedSageActiveEnvs.includes(env)) {
    throw new Error(`Environment ${env} is not allowed`);
  }
  return `https://api.${env}.active.sage.com/graphql`;
}

const sbcAuthEnvBySageActiveEnv = {
  'stage':'stage',
  'fr':'prodFR',
  'es':'prodES',
  'de':'prodDE'
};

const apiKeysByEnv = {
  'stage': process.env.API_KEY_STAGE,
  'fr': process.env.API_KEY_FR,
  'es': process.env.API_KEY_ES,
  'de': process.env.API_KEY_DE
};

const sbcAuthConfigBySageActiveEnvs = {
  'stage': {
    clientId: process.env.CLIENTID_STAGE,
    sbcAuthUrl: "https://stg-sbcauth.sage.fr"
  },
  'prodFR': {
    clientId: process.env.CLIENTID_FR,
    sbcAuthUrl: "https://sbcauth.sage.fr"
  },
  'prodES': {
    clientId: process.env.CLIENTID_ES,
    sbcAuthUrl: "https://sbcauth.sage.fr"
  },
  'prodDE': {
    clientId: process.env.CLIENTID_DE,
    sbcAuthUrl: "https://sbcauth.sage.fr"
  }
};


function getApiKeyForEnv(env) {
  return apiKeysByEnv[env] || '';
}

app.use('/api', (req, res, next) => {
  const env = req.header('x-sageactive-env').toLowerCase();
  if (!apiConfigCache[env]) {
    const target = determineApiTarget(env);
    const apiKey = getApiKeyForEnv(env);
    apiConfigCache[env] = { target, apiKey };
  }

  const { target, apiKey } = apiConfigCache[env];

  const proxy = createProxyMiddleware({
    target: target,
    changeOrigin: true,
    pathRewrite: {'^/api': ''},
    onProxyReq: (proxyReq, req, res) => {
      proxyReq.removeHeader('x-sageactive-env');
      proxyReq.removeHeader('x-original-url');
      if (apiKey) 
        proxyReq.setHeader('x-api-key', apiKey);
      else 
        proxyReq.removeHeader('x-api-key');
    },
    selfHandleResponse: true, 
    onProxyRes: (proxyRes, req, res) => {
      let body = [];
      proxyRes.on('data', chunk => {
        body.push(chunk);
      });
      proxyRes.on('end', () => {
        body = Buffer.concat(body);
        const bodyString = body.toString('utf8');
  
        res.writeHead(proxyRes.statusCode, proxyRes.headers);
        res.end(bodyString);
      });
    },
  });
  
  proxy(req, res, next);
  
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});