// app/[lang]/login/page.tsx

import { MdEmail, MdKey } from "react-icons/md";
import Link from 'next/link';
import { cookies } from 'next/headers';
import { createClient } from '@/utils/supabase/server';
import { getDictionary } from '@/app/translation/dictionary';
import { Locale } from '@/i18n.config';
import { InputField } from '@/components/InputField';
import { Logo } from "@/components/Logo";

export default async function Login({
  searchParams,
  params: { lang }
}: {
  searchParams: { message: string },
  params: { lang: Locale }
}) {
  console.log('Login Page: Server-side rendering');
  const { page } = await getDictionary(lang);
  const cookieStore = cookies();
  const supabase = createClient(cookieStore);

  const signIn = async (event: React.FormEvent<HTMLFormElement>) => {
    'use server';
    event.preventDefault();


    const formData = new FormData(event.currentTarget);
    const email = formData.get('email') as string;
    const password = formData.get('password') as string;

    const { data: authData, error } = await supabase.auth.signInWithPassword({
        email,
        password,
    });

    const user = authData?.user;

   if (error || !user) {
    console.error('Login error:', error?.message);
    return `/login?message=${page.login.errorMessage}`;
}

const { data: userData, error: userDataError } = await supabase
      .from('Unconfirmed Users')
      .select('*')
      .eq('user_id', user.id)
      .single();

    if (userDataError) {
      console.error('Error fetching user data:', userDataError);
      return `/login?message=${page.login.errorMessage}`;
    }

    if (userData && userData.initialAccountSetup === 'False') {
      const targetTable = userData.accountType === 'Job Seeker' ? 'Job Seekers' : 'Recruiters';
      const { error: insertError } = await supabase
        .from(targetTable)
        .insert([userData]);

      if (insertError) {
        console.error('Error inserting user data:', insertError);
        return `/login?message=${page.login.errorMessage}`;
      }

      const { error: deleteError } = await supabase
        .from('Unconfirmed Users')
        .delete()
        .match({ user_id: user.id });

      if (deleteError) {
        console.error('Error deleting unconfirmed user:', deleteError);
      }

      const { error: updateError } = await supabase
        .from(targetTable)
        .update({ initialAccountSetup: 'Completed' })
        .match({ user_id: user.id });

      if (updateError) {
        console.error('Error updating initial account setup status:', updateError);
      }
    }

    return '/';
  };

return(
//...
 <form
            className="flex flex-col items-center justify-center gap-2 text-foreground"
            style={{ marginTop: '0px', width: '100%' }}
            onSubmit={signIn}
          >
//...

"use server";
export const yourAction = async (prevSate: any, formData: FormData) => {}

// inside action
return {
    message: "Your password is wrong!",
  };

// on the client:
const [state, formAction] = useFormState(yourAction, {
        message: ''
    });

"use client";
function YourButton() {
const { pending } = useFormStatus();

return (
  <button type="submit" loading={pending}></button> // or disabled, set disabled true when pending or do something else
)
}

function YourForm(){
const [state, formAction] = useFormState(yourAction, {
        message: ''
    });
return (
<form action={formAction}>
            <input name="username" value= />
            <input name="password" value= />
            <YourButton />
        </form>
)
}

// hooks/useMounted.ts
import { useEffect, useState } from "react";

export default function useMounted(): boolean {
  const [mounted, setMounted] = useState(false);

  useEffect(() => {
    setMounted(true);
    return () => setMounted(false);
  }, []);

  return mounted;
}

// app/[lang]/signup/page.tsx

import { getDictionary } from '@/app/translation/dictionary';
import SignUp from '@/components/sign-up-page/sign-up-form';

// Define the type for props
type Props = {
  params: {
    lang: "en" | "ro";
  }
}

const Page = async ({ params: { lang } }: Props) => {
  const dictionary = await getDictionary(lang);
  
  return (
    <>
      <SignUp dictionary={dictionary} lang={lang} />
    </>
  );
}

export default Page;

const signIn = async (data: LoginFormData) => {
    'use server';
    const { email, password } = data;

    const { data: authData, error } = await supabase.auth.signInWithPassword({
      email,
      password,
    });

    // Access user from the authData object
    const user = authData?.user;

    if (error || !user) {
      console.error('Login error:', error?.message);
      return `/login?message=${page.login.errorMessage}`;
    }

    // Check if user has completed initial account setup
    const { data: userData, error: userDataError } = await supabase
      .from('Unconfirmed Users')
      .select('*')
      .eq('user_id', user.id)
      .single();

    if (userDataError) {
      console.error('Error fetching user data:', userDataError);
      return `/login?message=${page.login.errorMessage}`;
    }

    if (userData && userData.initialAccountSetup === 'False') {
      // Move user data to the respective table based on accountType
      const targetTable = userData.accountType === 'Job Seeker' ? 'Job Seekers' : 'Recruiters';
      const { error: insertError } = await supabase
        .from(targetTable)
        .insert([userData]);

      if (insertError) {
        console.error('Error inserting user data:', insertError);
        return `/login?message=${page.login.errorMessage}`;
      }

      // Remove entry from Unconfirmed Users
      const { error: deleteError } = await supabase
        .from('Unconfirmed Users')
        .delete()
        .match({ user_id: user.id });

      if (deleteError) {
        console.error('Error deleting unconfirmed user:', deleteError);
      }

      const { error: updateError } = await supabase
        .from(targetTable)
        .update({ initialAccountSetup: 'Completed' })
        .match({ user_id: user.id });

      if (updateError) {
        console.error('Error updating initial account setup status:', updateError);
      }
    }

    return '/';
  };

const signIn = async (data: LoginFormData) => {

async function signIn(data: LoginFormData) {

interface LoginFormProps {
  dictionary: any; // Define the proper type for your dictionary
  onSignIn: (data: LoginFormData) => void;
  errorMessage: string | null;
}

const LoginForm: React.FC<LoginFormProps> = ({ dictionary, onSignIn, errorMessage }) => {
  // Define Zod schema
  //console.log('Dictionary contents:', dictionary);
  const loginSchema = z.object({
    email: z.string().email({ message: dictionary.invalidEmailError }),
    password: z.string().min(6, { message: dictionary.passwordMinLengthError })
  });

Unhandled Runtime Error
Error: Connection closed.
Call Stack
tu

/Users/johnnyrobert/Next JS/Projects/jobs-bringer-web/node_modules/next/dist/compiled/next-server/app-page.runtime.dev.js (35:305904)
e.exports.<anonymous>

/Users/johnnyrobert/Next JS/Projects/jobs-bringer-web/node_modules/next/dist/compiled/next-server/app-page.runtime.dev.js (35:308051)
e.exports.emit

node:events (523:35)
finish

node:internal/streams/writable (757:10)
process.processTicksAndRejections

node:internal/process/task_queues (82:21)

 // Custom onSubmit function that awaits the onSignIn function
  const onSubmit = async (data: LoginFormData) => {
    try {
      await onSignIn(data);
    } catch (error) {
      console.error('Failed to sign in:', error);
    }
  };

//app/[lang]/login/login-form.tsx
interface LoginFormData {
  email: string;
  password: string;
}

interface LoginFormProps {
  dictionary: any;
  onSignIn: (FormData: FormData) => Promise<void>;
  errorMessage: string | null;
}

const LoginForm: React.FC<LoginFormProps> = ({ dictionary, onSignIn, errorMessage }) => {
  
  const loginSchema = z.object({
    email: z.string().email({ message: dictionary.invalidEmailError }),
    password: z.string().min(6, { message: dictionary.passwordMinLengthError })
  });

//app/[lang]/login/page.tsx
// Now 'data' is typed with 'LoginFormData'
  async function signIn(data: LoginFormData) {
    'use server';
    const { email, password } = data;
const { data: authData, error } = await supabase.auth.signInWithPassword({
      email,
      password,
    });

    const user = authData?.user;

    if (error || !user) {
      console.error('Login error:', error?.message);
      return `/login?message=${page.login.errorMessage}`;
    }

    const { data: userData, error: userDataError } = await supabase
      .from('Unconfirmed Users')
      .select('*')
      .eq('user_id', user.id)
      .single();

    if (userDataError) {
      console.error('Error fetching user data:', userDataError);
      return `/login?message=${page.login.errorMessage}`;
    }

    if (userData && userData.initialAccountSetup === 'False') {
   
      const targetTable = userData.accountType === 'Job Seeker' ? 'Job Seekers' : 'Recruiters';
      const { error: insertError } = await supabase
        .from(targetTable)
        .insert([userData]);

      if (insertError) {
        console.error('Error inserting user data:', insertError);
        return `/login?message=${page.login.errorMessage}`;
      }

      const { error: deleteError } = await supabase
        .from('Unconfirmed Users')
        .delete()
        .match({ user_id: user.id });

      if (deleteError) {
        console.error('Error deleting unconfirmed user:', deleteError);
       
      }

      const { error: updateError } = await supabase
        .from(targetTable)
        .update({ initialAccountSetup: 'Completed' })
        .match({ user_id: user.id });

      if (updateError) {
        console.error('Error updating initial account setup status:', updateError);
      }
    }
  };

import { redirect } from 'next/navigation'

//app/[lang]/login/page.tsx
// Define the shape of your form data
  async function signIn(data: FormData) {
    'use server';
    const { email, password } = data as unknown as LoginFormData;

    const { data: authData, error } = await supabase.auth.signInWithPassword({
      email,
      password,
    });

    const user = authData?.user;

    if (error || !user) {
      console.error('Login error:', error?.message);
      redirect(`/login?message=${page.login.errorMessage}`);
      return;
    }

    const { data: userData, error: userDataError } = await supabase
      .from('Unconfirmed Users')
      .select('*')
      .eq('user_id', user.id)
      .single();

    if (userDataError) {
      console.error('Error fetching user data:', userDataError);
      redirect(`/login?message=${page.login.errorMessage}`);
      return;
    }

    if (userData && userData.initialAccountSetup === 'False') {
      const targetTable = userData.accountType === 'Job Seeker' ? 'Job Seekers' : 'Recruiters';
      const { error: insertError } = await supabase
        .from(targetTable)
        .insert([userData]);

      if (insertError) {
        console.error('Error inserting user data:', insertError);
        redirect(`/login?message=${page.login.errorMessage}`);
        return;
      }

      const { error: deleteError } = await supabase
        .from('Unconfirmed Users')
        .delete()
        .match({ user_id: user.id });

      if (deleteError) {
        console.error('Error deleting unconfirmed user:', deleteError);
      }

      const { error: updateError } = await supabase
        .from(targetTable)
        .update({ initialAccountSetup: 'Completed' })
        .match({ user_id: user.id });

      if (updateError) {
        console.error('Error updating initial account setup status:', updateError);
      }
    }
    redirect('/')
  };

// Define Zod schema
const loginSchema = z.object({
  email: z.string().email({ message: dictionary.invalidEmailError }),
  password: z.string().min(6, { message: dictionary.passwordMinLengthError })
});

type LoginFormData = z.infer<typeof loginSchema>

  // Custom onSubmit function that awaits the onSignIn function
  const onSubmit = async (data: LoginFormData) => {
    try {
      await onSignIn(data as any);
    } catch (error) {
      console.error('Failed to sign in:', error);
    }
  };

// app/[lang]/login/login-form.tsx
'use client';

interface LoginFormProps {
  dictionary: any; // Define the proper type for your dictionary
  onSignIn: (FormData: FormData) => Promise<void>; // Make sure this is typed to return a Promise
  errorMessage: string | null;
}

/ Custom onSubmit function that awaits the onSignIn function
  const onSubmit = async (data: LoginFormData) => {
    try {
      await onSignIn(data as any);
    } catch (error) {
      console.error('Failed to sign in:', error);
    }
  };

//utils/supabase/server.ts
import { createServerClient, type CookieOptions } from '@supabase/ssr'
import { cookies } from 'next/headers'

export const createClient = (cookieStore: ReturnType<typeof cookies>) => {
  return createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        get(name: string) {
          return cookieStore.get(name)?.value
        },
        set(name: string, value: string, options: CookieOptions) {
          try {
            cookieStore.set({ name, value, ...options })
          } catch (error) {
            // The `set` method was called from a Server Component.
            // This can be ignored if you have middleware refreshing
            // user sessions.
          }
        },
        remove(name: string, options: CookieOptions) {
          try {
            cookieStore.set({ name, value: '', ...options })
          } catch (error) {
            // The `delete` method was called from a Server Component.
            // This can be ignored if you have middleware refreshing
            // user sessions.
          }
        },
      },
    }
  )
}

 async function signIn(data: FormData) {
    'use server';

[{
    "resource": "/Users/johnnyrobert/Next JS/Projects/jobs-bringer-web/app/[lang]/login/page.tsx",
    "owner": "typescript",
    "code": "2554",
    "severity": 8,
    "message": "Expected 1 arguments, but got 2.",
    "source": "ts",
    "startLineNumber": 60,
    "startColumn": 54,
    "endLineNumber": 60,
    "endColumn": 58
}]

onSignIn: (data: FormData, page: any) => Promise<void>;  // Make sure this is typed to return a Promise

const LoginForm: React.FC<LoginFormProps> = ({ dictionary, onSignIn, errorMessage }) => {

 // Custom onSubmit function that awaits the onSignIn function
  const onSubmit = async (data: LoginFormData) => {
    try {
      await onSignIn(data as any);
    } catch (error) {
      console.error('Failed to sign in:', error);
    }
  };