Google Calendar Integration Setup

Google({
  clientId: process.env.AUTH_GOOGLE_ID,
  clientSecret: process.env.AUTH_GOOGLE_SECRET,
  authorization: {
    params: {
      scope: "openid email profile https://www.googleapis.com/auth/calendar.events",
      access_type: "offline",
    }
  }
})

if (profile.email === process.env.ADMIN_EMAIL! && account.refresh_token) {
  token.refreshToken = account.refresh_token
  console.log('THIS IS NEW THE refresh_token', token.refreshToken);
  await updateRefreshTokenInDb(user.id, token.refreshToken as string)
}

export async function updateRefreshTokenInDb(userId: string, refreshToken: string) {
  try {
    const response = await db.user.update({
      where: { id: userId },
      data: {
        googleRefreshToken: refreshToken
      }
    })
    return response
  } catch (error) {
    console.log(error);
    return error
  }
}

export async function getRefreshTokenFromDb(userEmail: string) {
  try {
    const response = await db.user.findUnique({
      where: { email: userEmail },
      select: {
        googleRefreshToken: true
      }
    })
    return response?.googleRefreshToken
  } catch (error) {
    console.log(error);
    return error
  }
}

export async function GET() {
  const calendarId = process.env.CALENDAR_ID!;
  const apiKey = process.env.CALENDAR_API_KEY!;
  const now = new Date().toISOString();
  const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events?key=${apiKey}&timeMin=${now}`;
  
  try {
    const response = await KY(Method.GET, url);
    const data = response.items as calendarEvent[];
    
    const cleanData: calendarEvent[] = data.map((ev) => ({
      start: ev.start,
      end: ev.end,
      status: ev.status,
    }));
    
    return NextResponse.json(cleanData);
  } catch (error) {
    console.log(error);
    return NextResponse.json({ error: 'Failed to fetch calendar events' }, { status: 500 });
  }
}

export async function POST(request: NextRequest) {
  try {
    const { preferenceId } = await request.json();
    const calendarId = process.env.CALENDAR_ID!;
    
    // Setup OAuth2 client
    const auth = new google.auth.OAuth2(
      process.env.AUTH_GOOGLE_ID,
      process.env.AUTH_GOOGLE_SECRET,
      process.env.GOOGLE_REDIRECT_URI
    )
    
    // Get admin's refresh token from database
    const refreshToken = await getRefreshTokenFromDb(process.env.ADMIN_EMAIL!);
    auth.setCredentials({ refresh_token: refreshToken as string });
    
    // Find the virtual class to schedule
    const body = await findVirtualClass(preferenceId)
    
    if (!body?.success) {
      return NextResponse.json({ error: "Virtual class not found" }, { status: 404 });
    }
    
    const calendar = google.calendar({ version: 'v3', auth });
    
    // Create event in Google Calendar
    const googleCalendarEvent = await createGoogleCalendarEvent(
      calendarId, 
      calendar, 
      body.response
    );
    
    if (googleCalendarEvent?.success) {
      // Update virtual class with event details
      await updateVirtualClass(googleCalendarEvent.response, body.response);
    }
    
    return NextResponse.json({ success: true, message: "Event created successfully" });
  } catch (error) {
    console.error(error);
    return NextResponse.json({ error: 'Failed to create calendar event' }, { status: 500 });
  }
}

export async function createGoogleCalendarEvent(calendarId: string, calendar: any, eventData: any) {
  const { startTime, endTime, classType, maxParticipants } = eventData;
  
  const bookingClass = {
    summary: `Clase de Inglés`,
    description: `La clase sera ${classType} con x${maxParticipants == 0 ? 1 : maxParticipants} participantes`,
    start: {
      dateTime: startTime,
      timeZone: 'America/Argentina/Buenos_Aires',
    },
    end: {
      dateTime: endTime,
      timeZone: 'America/Argentina/Buenos_Aires',
    },
    conferenceData: {
      createRequest: {
        requestId: `meet-${Date.now()}`,
        conferenceSolutionKey: {
          type: 'hangoutsMeet',
        },
      },
    },
    transparency: "opaque", // Shows as busy in calendar
  }
  
  try {
    const response = await calendar.events.insert({
      calendarId,
      requestBody: bookingClass,
      conferenceDataVersion: 1, // Required for Google Meet link
    });
    
    return { response: response.data, success: true };
  } catch (error) {
    console.error("Error creating calendar event:", error);
    throw error;
  }
}

const saveCalendarEvent: Omit<CalendarEvent, 'bookedById' | 'participantsIds'> = {
  googleEventId: googleCalendarEvent.id,
  classType: classType,
  accessCode: randomCode,
  startTime: new Date(googleCalendarEvent.start.dateTime),
  endTime: new Date(googleCalendarEvent.end.dateTime),
  maxParticipants: maxParticipants,
  currentParticipants: 1,
  classPrice: 111,
  htmlLink: googleCalendarEvent.conferenceData.entryPoints[0].uri,
  status: "scheduled",
  summary: `${googleCalendarEvent.summary}. ${googleCalendarEvent.description}`,
  learningFocus: text,
  preferenceId: preferenceId,
  hostType: 'anfitrion',
}

googleCalendarEvent.conferenceData.entryPoints[0].uri

timeZone: 'America/Argentina/Buenos_Aires'

export async function listEvents() {
  try {
    const calendarId = process.env.CALENDAR_ID!;
    const auth = new google.auth.GoogleAuth({
      credentials: JSON.parse(process.env.GOOGLE_SERVICE_ACCOUNT_JSON!),
      scopes: ['https://www.googleapis.com/auth/calendar']
    });
    
    const calendar = google.calendar({ version: 'v3', auth });
    
    const response = await calendar.events.list({
      calendarId: calendarId,
      maxResults: 10,
      singleEvents: true,
      orderBy: "startTime",
      timeMin: new Date().toISOString()
    });
    
    const events = response.data.items;
    console.log("Eventos completos:", JSON.stringify(events, null, 2));
  } catch (error) {
    console.error("Error listing events:", error);
  }
}