'use server'
import { createClient } from '@/utils/supabase/server';
import type { NextApiRequest, NextApiResponse } from 'next';
import type { SignupData } from '@/utils/types';
import { cookies } from 'next/headers';

export const api = async (req: NextApiRequest, res: NextApiResponse) => {
  
    console.log(`Request received: ${req.method} ${req.url}`);
    console.log(`Request body:`, req.body);

    if (req.method === 'POST') {
        
        const { personalDetails, accountType, accountDetails }: SignupData = req.body;

      
        const cookieStore = cookies();
        const supabase = createClient(cookieStore);

       
        const { data: signUpData, error: signUpError } = await supabase.auth.signUp({
            email: accountDetails.email,
            password: accountDetails.password,
        });

        if (signUpError) {
            console.error('Supabase signUp error:', signUpError);
            return res.status(500).json({ error: signUpError.message });
        }

      
        if (!signUpData.user) {
            console.error('User was not created.');
            return res.status(500).json({ error: "User was not created." });
        }

  const targetTable = accountType.userType === 'Job Seeker' ? 'Job Seekers' : 'Applicants';

        const userData = {
            userId: signUpData.user.id,
            firstName: personalDetails.firstName,
            middleName: personalDetails.middleName,
            lastName: personalDetails.lastName,
            country: personalDetails.country,
            dateOfBirth: personalDetails.dateOfBirth,
            userType: accountType.userType,
            email: accountDetails.email,
         
        };

        const { data: insertData, error: insertError } = await supabase
            .from(targetTable)
            .insert([userData]);

        if (insertError) {
            console.error('Error inserting user data:', insertError);
           
            return res.status(500).json({ error: insertError.message });
        }

        // Handle success
        console.log(`User data inserted successfully:`, insertData);
        return res.status(200).json({ data: { user: signUpData.user, additionalData: insertData } });
    } else {
        // Handle any non-POST requests
        console.log(`Non-POST request received: ${req.method}`);
        res.setHeader('Allow', ['POST']);
        res.status(405).end(`Method ${req.method} Not Allowed`);
    }
};

//app/auth/callback/route.ts

import { createServerClient, type CookieOptions } from '@supabase/ssr'
import { type EmailOtpType } from '@supabase/supabase-js'
import { cookies } from 'next/headers'
import { NextRequest, NextResponse } from 'next/server'

export async function GET(request: NextRequest) {
  const { searchParams } = new URL(request.url)
  const token_hash = searchParams.get('token_hash')
  const type = searchParams.get('type') as EmailOtpType | null
  const next = searchParams.get('next') ?? '/'
  const redirectTo = request.nextUrl.clone()
  redirectTo.pathname = next

  if (token_hash && type) {
    const cookieStore = cookies()
    const supabase = 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) {
            cookieStore.set({ name, value, ...options })
          },
          remove(name: string, options: CookieOptions) {
            cookieStore.delete({ name, ...options })
          },
        },
      }
    )

    const { error } = await supabase.auth.verifyOtp({
      type,
      token_hash,
    })
    if (!error) {
      return NextResponse.redirect(redirectTo)
    }
  }

  // return the user to an error page with some instructions
  redirectTo.pathname = '/auth/auth-code-error'
  return NextResponse.redirect(redirectTo)
}

const body = await req.json()
console.log(`Request received: ${req.method} ${req.url}`)
  console.log('Request body:', body)

  const { personalDetails, accountType, accountDetails }: SignupData = body

[Log] Form Submitted
Object

accountDetails: {email: "mail@mail.com", confirmEmail: "mail@mail.com", password: "mail@mail.com", confirmPassword: "mail@mail.com"}

accountType: {userType: "job_seeker"}

personalDetails: {firstName: "q", middleName: "q", lastName: "q", country: "Qatar", dateOfBirth: "1994-01-18"}

Object Prototype
---
[Error] Failed to load resource: the server responded with a status of 500 (Internal Server Error) (submit, line 0)
---
[Error] Error submitting form data: 500 Internal Server Error
    (anonymous function) (app-index.js:34)
    (anonymous function) (hydration-error-info.js:41)
    (anonymous function) (sign-up-form.tsx:92)
---
[Error] Error details: – {}
    (anonymous function) (app-index.js:34)
    (anonymous function) (hydration-error-info.js:41)
    (anonymous function) (sign-up-form.tsx:93)

johnnyrobert@Johnnys-MacBook-Air jobs-bringer-web % npm run dev

> dev
> next dev

   â–² Next.js 14.0.4
   - Local:        http://localhost:3000
   - Environments: .env.local

 ✓ Ready in 2s
 ✓ Compiled /middleware in 206ms (147 modules)
 â—‹ Compiling /[lang]/signup/submit ...
 ✓ Compiled /[lang]/signup/submit in 640ms (150 modules)
Request received: POST http://localhost:3000/en/signup/submit
Request body: ReadableStream { locked: false, state: 'readable', supportsBYOB: false }
Request received: POST http://localhost:3000/en/signup/submit
Request body: {
  personalDetails: {
    firstName: 'q',
    middleName: 'q',
    lastName: 'q',
    country: 'Qatar',
    dateOfBirth: '1994-01-18'
  },
  accountType: { userType: 'job_seeker' },
  accountDetails: {
    email: 'mail@mail.com',
    confirmEmail: 'mail@mail.com',
    password: 'mail@mail.com',
    confirmPassword: 'mail@mail.com'
  }
}
Error inserting user data: {}

const { data: insertData, error: insertError } = await supabase
    .from(targetTable)
    .insert([userData])