import NextAuth from 'next-auth';
import type { AuthOptions } from 'next-auth';
import CredentialsProvider from 'next-auth/providers/credentials';
const authOptions: AuthOptions = {
  providers: [
    CredentialsProvider({
      name: 'Credentials',
      credentials: {
        email: { label: 'Email', type: 'text' },
        password: { label: 'Password', type: 'password' },
      },
      async authorize(credentials : any, _req) {

        if (typeof credentials !== 'undefined') {
          if (credentials.user !== undefined) {
            const user = JSON.parse(credentials.user);
            return {
              id: user.id,
              name: user.first_name + ' ' + user.last_name,
              email: user.email,
              image: null,
              apiToken: user.token,
              role: user.role,
              permissions: user.permissions, // Add permissions
              first_login: user.first_login,
              training_video_watched: user.training_video_watched,
              training_video_progress: user.training_video_progress,
              training_video_progress_detail: user.training_video_progress_detail,
              cities: user.city,
              designations: user.designation,
              profile_photo: user.profile_photo,
            };
          } else {
            return null;
          }
        } else {
          return null;
        }
      },
    }),
  ],
  callbacks: {
    async jwt({ token, user, trigger, session }) {
      // the processing of JWT occurs before handling sessions.

      if (user !== undefined) {
        token.accessToken = user.apiToken;
        token.refreshToken = user.refreshToken;
        token.accessTokenExpires = user.accessTokenExpires;
        token.role = user.role;
        token.id = user.id;
        token.permissions = user.permissions;
        token.first_login = user.first_login;
        token.training_video_watched = user.training_video_watched;
        token.training_video_progress = user.training_video_progress;
        token.training_video_progress_detail = user.training_video_progress_detail;
        token.cities = user.cities;
        token.designations = user.designations;
        token.profile_photo = user.profile_photo;
      }

      // Handle session updates (e.g., profile photo change)
      if (trigger === 'update' && session?.profile_photo !== undefined) {
        token.profile_photo = session.profile_photo;
      }

      // Handle session updates after the training video gate is completed, and
      // background refreshes of the live training status (e.g. AuthProvider syncing
      // the session after a new mandatory video is published server-side).
      if (trigger === 'update' && session?.training_video_watched !== undefined) {
        token.training_video_watched = session.training_video_watched;
      }
      if (trigger === 'update' && session?.training_video_progress !== undefined) {
        token.training_video_progress = session.training_video_progress;
      }
      if (trigger === 'update' && session?.training_video_progress_detail !== undefined) {
        token.training_video_progress_detail = session.training_video_progress_detail;
      }

      return token;
    },

    //  The session receives the token from JWT
    async session({ session, token }) {
      return {
        ...session,
        user: {
          ...session.user,
          accessToken: token.accessToken as string,
          refreshToken: token.refreshToken as string,
          role: token.role,
          id: token.id,
          permissions: token.permissions,
          first_login: token.first_login,
          training_video_watched: token.training_video_watched,
          training_video_progress: token.training_video_progress,
          training_video_progress_detail: token.training_video_progress_detail,
          cities: token.cities,
          designations: token.designations,
          profile_photo: token.profile_photo as string | undefined,
        },
        error: token.error,
      };
    },
  },
  secret: process.env.NEXTAUTH_SECRET,
  pages: {
    signIn: '/auth/login',
  },
};

const handler = NextAuth(authOptions);

export { handler as GET, handler as POST };