const axios = require('axios');
const { Redis } = require('@upstash/redis');
 
 
exports.onExecutePostLogin = async (event, api) => {
  const redis = new Redis({
    url: event.secrets.UPSTASH_REDIS_REST_URL,
    token: event.secrets.UPSTASH_REDIS_REST_TOKEN,
  });
 
  const getToken = async () => {
    const redisToken = "access_token";
    try {
      const cachedToken = await redis?.get(redisToken);
      if (cachedToken) {
        return cachedToken;
      }
      const options = {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          client_id: event.secrets.AUTH0_TRACEAPI_CLIENT_ID,
          client_secret: event.secrets.AUTH0_TRACEAPI_CLIENT_SECRET,
          audience: event.secrets.TRACEAPI_AUDIENCE,
          grant_type: "client_credentials",
        }),
      };
 
      try {
        const response = await fetch(
          `${event.secrets.AUTH0_TRACEAPI}`,
          options
        );
        const data = await response.json();
        const newToken = data.access_token;
        if (newToken) {
          await redis.set(redisToken, newToken, { ex: 86400 });
          return newToken;
        } else {
          throw new Error("Failed to fetch new token");
        }
      } catch (error) {
        console.error("Error during API request:", error);
      }
    } catch (error) {
      throw error;
    }
  };
 
  const getRoleToken = async () => {
    const redisToken = "access_role_token";
    try {
      const cachedToken = await redis?.get(redisToken);
      if (cachedToken) {
        return cachedToken;
      }
      const options = {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          client_id: event.secrets.AUTH0_MANAGEMENT_CLIENT_ID,
          client_secret: event.secrets.AUTH0_MANAGEMENT_CLIENT_SECRET,
          audience: event.secrets.MANAGEMENT_AUDIENCE,
          grant_type: "client_credentials",
        }),
      };
 
      try {
        const response = await fetch(
          `${event.secrets.AUTH0_MANAGEMENT_API}`,
          options
        );
        const data = await response.json();
        const newToken = data.access_token;
        if (newToken) {
          await redis.set(redisToken, newToken, { ex: 86400 });
          return newToken;
        } else {
          throw new Error("Failed to fetch new token");
        }
      } catch (error) {
        console.error("Error during API request:", error);
      }
    } catch (error) {
      throw error;
    }
  };
  const userId = event.user.user_id;
 
  const token = await getToken()
 
  const config = {
    headers: { Authorization: `Bearer ${token}` }
  };
  const assignRole = async () => {
    const roleToken = await getRoleToken()
    try {
      const body = {
        roles: ['<ROLE_ID>'] // Replace with the actual role_id of your desired starter role for every new user 
      };
      const url = `https://${event.secrets.AUTH0_DOMAIN}/api/v2/users/${userId}/roles`;
      const response = await axios.post(url, body, {
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${roleToken}`,
          'cache-control': 'no-cache'
        }
      });
 
      console.log(`Role "Playground" assigned to user ${userId}. Response:`, response.data);
    } catch (error) {
      console.error(`Error assigning role "Playground" to user ${userId}:`, error.response.data || error.message);
    }
  };
  try {
    // Check if userId is already in the list
    const url = '<YOUR_API_URL>/api/get_userids';
    const response = await axios.get(url, config);
 
    if (response.statusText === 'OK') {
      const userList = response.data;
      if (!userList.includes(userId)) {
 
        const userData = {
          user_id: userId,
          // Include other user information if needed
        };
 
        // Call the API to store the user ID using POST method with query parameter
        const apiUrl = '<YOUR_API_URL>/api/create_user';
        const saveResponse = await axios.post(apiUrl, userData, {
          headers: config.headers,
          params: {
            user_id: userId,
          }
        });
        await assignRole();
        console.log(`User ID ${userId} saved successfully. Response:`, saveResponse.data);
      } else {
        console.log(`User ID ${userId} already exists.`);
      }
    }
  } catch (error) {
    console.error('Error fetching or saving user ID:', error);
  }
};
 

const axios = require('axios');
const { Redis } = require('@upstash/redis');
 
exports.onExecutePostLogin = async (event, api) => {
  const redis = new Redis({
    url: event.secrets.UPSTASH_REDIS_REST_URL,
    token: event.secrets.UPSTASH_REDIS_REST_TOKEN,
  });
 
  const getToken = async () => {
    const redisToken = "access_token";
    try {
      const cachedToken = await redis?.get(redisToken);
      if (cachedToken) {
        return cachedToken;
      }
      const options = {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          client_id: event.secrets.AUTH0_TRACEAPI_CLIENT_ID,
          client_secret: event.secrets.AUTH0_TRACEAPI_CLIENT_SECRET,
          audience: event.secrets.TRACEAPI_AUDIENCE,
          grant_type: "client_credentials",
        }),
      };
 
      try {
        const response = await fetch(
          `${event.secrets.AUTH0_TRACEAPI}`,
          options
        );
        const data = await response.json();
        const newToken = data.access_token;
        if (newToken) {
          await redis.set(redisToken, newToken, { ex: 86400 });
          return newToken;
        } else {
          throw new Error("Failed to fetch new token");
        }
      } catch (error) {
        console.error("Error during API request:", error);
      }
    } catch (error) {
      throw error;
    }
  };
  const userId = event.user.user_id;
 
  const token = await getToken()
 
  const config = {
    headers: { Authorization: `Bearer ${token}` }
  };
  try {
    // Check if userId is already in the list
    const url = '<YOUR_API_URL>/api/get_userids';
    const response = await axios.get(url, config);
 
    if (response.statusText === 'OK') {
      const userList = response.data;
      if (userList.includes(userId)) {
 
 
        const projectsUrl = '<YOUR_API_URL>/api/get_projects';
        const projectsListResponse = await axios.get(projectsUrl, {
          params: { user_id: userId }, // Pass user_id as a query parameter
          headers: config.headers
        });
        if (projectsListResponse.statusText === "OK") {
          const projectsList = projectsListResponse.data.projects;
          let projectExists = false;
          for (let i = 0; i < projectsList.length; i++) {
            if (projectsList[i].name === "Default Project") {
              projectExists = true;
              console.log("Skipping default project creation")
              break;
            }
          }
 
          if (!projectExists) {
            // Define the payload data
            const payload = {
              user_id: userId,
              project_name: 'Default Project',
              project_description: 'This is the coai default project created after registration',
              project_tags: 'coai',
              project_retention: 0
            };
 
            const postUrl = '<YOUR_API_URL>/api/create_project';
 
            // Extract token from config
            const token = config.headers['Authorization'];
 
            const queryString = Object.keys(payload)
              .map(key => encodeURIComponent(key) + '=' + encodeURIComponent(payload[key]))
              .join('&');
 
            const urlWithParams = `${postUrl}?${queryString}`;
 
            // Make the POST request with payload as query parameters
            await fetch(urlWithParams, {
              method: 'POST',
              headers: {
                'Content-Type': 'application/json',
                'Authorization': token
              }
            })
              .then(async response => {
                // Check if the response was successful
                if (!response.ok) {
                  const responseData = await response.json();
                  throw new Error(JSON.stringify(responseData));
                }
                // Parse the JSON response
                return response.json();
              })
              .then(data => {
                console.log('Response:', data);
              })
              .catch(error => {
                console.error('Error:', error);
              });
 
          }
 
        }
      } else {
        console.log(`User does not exist.`);
      }
    }
  } catch (error) {
    console.error('Error fetching or saving user ID:', error);
  }
};