/**
 * Profile Customization tRPC Router
 * Handles avatar uploads, display name changes, and profile customization
 */

import { z } from 'zod';
import { protectedProcedure, router } from '../_core/trpc.ts';
import {
  updateDisplayName,
  uploadAvatar,
  updateProfileCustomization,
  getProfileCustomization,
  deleteAvatar,
  validateDisplayNameAvailability,
  getAvatarUploadUrl,
  getSuggestedDisplayNames,
} from '../profileCustomizationService.ts';

export const profileCustomizationRouter = router({
  /**
   * Get profile customization
   */
  getCustomization: protectedProcedure.query(async ({ ctx }) => {
    try {
      const customization = await getProfileCustomization(ctx.user.id.toString());
      return customization;
    } catch (error) {
      console.error('[profileCustomizationRouter] Error fetching customization:', error);
      throw error;
    }
  }),

  /**
   * Update display name
   */
  updateDisplayName: protectedProcedure
    .input(
      z.object({
        displayName: z.string().min(2).max(50),
      })
    )
    .mutation(async ({ ctx, input }) => {
      try {
        const available = await validateDisplayNameAvailability(input.displayName, ctx.user.id.toString());
        if (!available) {
          throw new Error('Display name is not available');
        }

        const success = await updateDisplayName(ctx.user.id.toString(), input.displayName);
        return { success };
      } catch (error) {
        console.error('[profileCustomizationRouter] Error updating display name:', error);
        throw error;
      }
    }),

  /**
   * Upload avatar
   */
  uploadAvatar: protectedProcedure
    .input(
      z.object({
        imageBase64: z.string(),
        mimeType: z.string(),
      })
    )
    .mutation(async ({ ctx, input }) => {
      try {
        const imageBuffer = Buffer.from(input.imageBase64, 'base64');
        const avatarUrl = await uploadAvatar(ctx.user.id.toString(), imageBuffer, input.mimeType);

        if (!avatarUrl) {
          throw new Error('Failed to upload avatar');
        }

        return { avatarUrl };
      } catch (error) {
        console.error('[profileCustomizationRouter] Error uploading avatar:', error);
        throw error;
      }
    }),

  /**
   * Update profile customization
   */
  updateCustomization: protectedProcedure
    .input(
      z.object({
        displayName: z.string().min(2).max(50).optional(),
        avatarUrl: z.string().url().optional(),
        bio: z.string().max(500).optional(),
        theme: z.enum(['light', 'dark']).optional(),
        language: z.string().optional(),
      })
    )
    .mutation(async ({ ctx, input }) => {
      try {
        const customization = await updateProfileCustomization(ctx.user.id.toString(), input);
        return customization;
      } catch (error) {
        console.error('[profileCustomizationRouter] Error updating customization:', error);
        throw error;
      }
    }),

  /**
   * Delete avatar
   */
  deleteAvatar: protectedProcedure.mutation(async ({ ctx }) => {
    try {
      const success = await deleteAvatar(ctx.user.id.toString());
      return { success };
    } catch (error) {
      console.error('[profileCustomizationRouter] Error deleting avatar:', error);
      throw error;
    }
  }),

  /**
   * Validate display name availability
   */
  validateDisplayName: protectedProcedure
    .input(
      z.object({
        displayName: z.string().min(2).max(50),
      })
    )
    .query(async ({ ctx, input }) => {
      try {
        const available = await validateDisplayNameAvailability(input.displayName, ctx.user.id.toString());
        return { available };
      } catch (error) {
        console.error('[profileCustomizationRouter] Error validating display name:', error);
        throw error;
      }
    }),

  /**
   * Get avatar upload URL
   */
  getAvatarUploadUrl: protectedProcedure.query(async ({ ctx }) => {
    try {
      const uploadInfo = await getAvatarUploadUrl(ctx.user.id.toString());
      return uploadInfo;
    } catch (error) {
      console.error('[profileCustomizationRouter] Error getting upload URL:', error);
      throw error;
    }
  }),

  /**
   * Get suggested display names
   */
  getSuggestedNames: protectedProcedure.query(async ({ ctx }) => {
    try {
      const suggestions = await getSuggestedDisplayNames(ctx.user.id.toString(), ctx.user.username || 'Player');
      return { suggestions };
    } catch (error) {
      console.error('[profileCustomizationRouter] Error getting suggestions:', error);
      throw error;
    }
  }),
});