import axios from 'axios';
import CredentialsProvider from 'next-auth/providers/credentials';

import type { NextAuthConfig } from 'next-auth';

export const authConfig = {
  callbacks: {
    authorized({ auth, request: { nextUrl } }) {
      const isLoggedIn = !!auth?.user;
      const isOnDashboard = nextUrl.pathname.startsWith('/dashboard');
      if (isOnDashboard) {
        // Redirect unauthenticated users to login page
        return isLoggedIn;
      } else if (isLoggedIn) {
        return Response.redirect(new URL('/dashboard', nextUrl));
      }

      return true;
    },
  },
  pages: {
    signIn: '/login',
  },
  providers: [
    CredentialsProvider({
      name: 'Credentials',
      credentials: {
        username: { label: 'Email', type: 'text' },
        password: { label: 'Password', type: 'password' },
      },
      async authorize(credentials) {
        // Add logic here to look up the user from the credentials supplied
        const response = await axios.post('http://localhost:8000/api/user', credentials);
        const user = response.data;
        if (user) {
          // Any object returned will be saved in `user` property of the JWT
          return user;
        } else {
          // If you return null then an error will be displayed advising the user to check their details.
          return null;

          // You can also Reject this callback with an Error thus the user will be sent to the error page with the error message as a query parameter
        }
      },
    }),
  ],
} satisfies NextAuthConfig;

declare module 'next-auth' {
  interface User {
    token?: string;
  }
  interface Session {
    access_token: string;
  }
}

    return response()->json([
        ...$request->user()->toArray(),
        'token' => $request->user()->createToken('web')->plainTextToken,
    ]);

async authorize(credentials) {
        const parsedCredentials; 

        if (parsedCredentials.success) {
          //
          const user = await getUser({ email, password });

          if (!user) return null;

          return user;
        }

        return null;
      },

callbacks: {
    async jwt({ token, user, session, profile, account }) {
      if (user) {
        token.access_token = user.token;
      }

      return token;
    },
    async session({ session, token }) {
      if (session) {
        session.access_token = token.access_token as string;
      }

      return session;
    },
///////

const AuthContext = createContext<null | Partial<Session>>(null);

const AuthContextProvider = ({ session, children }: { session: Partial<Session> | null; children: ReactNode }) => {
  return <AuthContext.Provider value={session}>{children}</AuthContext.Provider>;
};

const useAuth = () => {
  const context = useContext(AuthContext);
  if (context === null) {
    throw new Error('useAuth must be used within an AuthProvider');
  }

  return context as Session & {
    access_token: string;
  };
};

export { AuthContextProvider, useAuth };

const session = await auth();

return (
<AuthContextProvider session={session}>
///
 </AuthContextProvider>

const session = useAuth();

  const getUser = async () => {
    try {
      const response = await axios.get('http://localhost:8000/api/user', {
        headers: {
          Authorization: `Bearer ${session?.access_token}`,
        },
      });

      console.log(response.data);

      return response.data;
    } catch (error) {
      console.error(error);

      return null;
    }
  };