/**
 * Property actions - Server actions for property management
 * Uses Better Auth session + Supabase to query the same database as the monorepo
 */

'use server'

import { createServerSupabaseClient } from '../database/server'
import { getSession } from '../auth/server'
import { createId } from '../utils/id-generator'
import type { CreatePropertyParams, Property, Database } from './types'

export type ActionResult<T = unknown> = {
  success: boolean
  data?: T
  error?: string
  message?: string
}

/**
 * Fetch all properties for the current user
 */
export async function getUserProperties(): Promise<ActionResult<Property[]>> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
        data: [],
      }
    }

    const supabase = await createServerSupabaseClient()

    // Query properties table with address relation
    const { data, error } = await supabase
      .from('properties')
      .select(`
        *,
        address:properties_addresses(*)
      `)
      .eq('owner_id', session.user.id)
      .order('created_at', { ascending: false })

    if (error) {
      return {
        success: false,
        error: error.message,
        data: [],
      }
    }

    return {
      success: true,
      data: data as Property[],
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to fetch properties',
      data: [],
    }
  }
}

/**
 * Get a specific property by ID for the current user
 */
export async function getPropertyById(propertyId: string): Promise<ActionResult<Property | null>> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return { success: false, error: 'Not authenticated', data: null }
    }

    const supabase = await createServerSupabaseClient()

    const { data, error } = await supabase
      .from('properties')
      .select(`*, address:properties_addresses(*)`)
      .eq('id', propertyId)
      .eq('owner_id', session.user.id)
      .single<Property>()

    if (error) {
      return { success: false, error: error.message, data: null }
    }

    return { success: true, data: data as Property }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to fetch property',
      data: null,
    }
  }
}

/**
 * Get the active property for the current session
 */
export async function getActiveProperty(): Promise<ActionResult<Property | null>> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
        data: null,
      }
    }

    const supabase = await createServerSupabaseClient()

    // Get session's active_property_id from sessions table
    const { data: sessionData, error: sessionError } = await supabase
      .from('auth_sessions')
      .select('active_property_id')
      .eq('user_id', session.user.id)
      .single<{ active_property_id: string | null }>()

    if (sessionError || !sessionData?.active_property_id) {
      return {
        success: true,
        data: null,
      }
    }

    // Get the property with address
    const { data, error } = await supabase
      .from('properties')
      .select(`
        *,
        address:properties_addresses(*)
      `)
      .eq('id', sessionData.active_property_id)
      .single<Property>()

    if (error) {
      return {
        success: false,
        error: error.message,
        data: null,
      }
    }

    return {
      success: true,
      data: data as Property,
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to fetch active property',
      data: null,
    }
  }
}

/**
 * Set the active property for the current session
 */
export async function setActiveProperty(propertyId: string | null): Promise<ActionResult> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
      }
    }

    const supabase = await createServerSupabaseClient()

    // Update session's active_property_id
    const { error } = await (supabase
      .from('auth_sessions') as any)
      .update({ active_property_id: propertyId })
      .eq('user_id', session.user.id)

    if (error) {
      return {
        success: false,
        error: error.message,
      }
    }

    return {
      success: true,
      message: propertyId ? 'Active property updated' : 'Active property cleared',
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to set active property',
    }
  }
}

/**
 * Create a new property
 */
export async function createProperty(params: CreatePropertyParams): Promise<ActionResult<Property>> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
      }
    }

    const supabase = await createServerSupabaseClient()

    // Generate IDs for address and property
    const addressId = createId('address')
    const propertyId = createId('property')

    // First, create the address
    const addressData = {
      id: addressId,
      street_number: params.streetNumber,
      route: params.route,
      city: params.city || '',
      state: params.state || '',
      postal_code: params.postalCode || '',
      country: params.country || 'US',
      latitude: params.center[1].toString(),
      longitude: params.center[0].toString(),
    }
    const { data: address, error: addressError } = (await (supabase
      .from('properties_addresses') as any)
      .insert(addressData)
      .select()
      .single()) as { data: Property['address'] | null; error: any }

    if (addressError || !address) {
      return {
        success: false,
        error: addressError?.message || 'Failed to create address',
      }
    }

    // Create the property
    const propertyData = {
      id: propertyId,
      name: params.name,
      address_id: address.id,
      owner_id: session.user.id,
      is_private: params.isPrivate !== undefined ? params.isPrivate : true,
      details_json: {
        coordinates: params.center,
        createdFrom: 'editor-app',
      },
    }
    const { data, error } = (await (supabase
      .from('properties') as any)
      .insert(propertyData)
      .select(`
        *,
        address:properties_addresses(*)
      `)
      .single()) as { data: Property | null; error: any }

    if (error) {
      return {
        success: false,
        error: error.message,
      }
    }

    // If scene graph is provided, create the model
    if (params.sceneGraph) {
      const modelId = createId('model')
      const { error: modelError } = await supabase.from('properties_models').insert({
        id: modelId,
        property_id: propertyId,
        version: 1,
        scene_graph: params.sceneGraph,
      } as any)

      if (modelError) {
        console.error('Failed to create model:', modelError)
        // Don't fail the property creation if model creation fails
      }
    }

    return {
      success: true,
      data: data as Property,
      message: 'Property created successfully',
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to create property',
    }
  }
}

/**
 * Check if a property with the given address already exists
 */
export async function checkPropertyDuplicate(params: {
  streetNumber?: string
  route?: string
  city?: string
  state?: string
  postalCode?: string
}): Promise<
  ActionResult<{
    isDuplicate: boolean
    isUserProperty?: boolean
    existingProperty?: Property
  }>
> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
      }
    }

    const supabase = await createServerSupabaseClient()

    // Query for existing property with matching address
    const { data, error } = await supabase
      .from('properties')
      .select(`
        *,
        address:properties_addresses!inner(*)
      `)
      .eq('address.street_number', params.streetNumber || '')
      .eq('address.route', params.route || '')
      .eq('address.city', params.city || '')
      .eq('address.state', params.state || '')
      .eq('address.postal_code', params.postalCode || '')
      .limit(1)

    if (error) {
      return {
        success: false,
        error: error.message,
      }
    }

    if (data && data.length > 0) {
      const existingProperty = data[0] as unknown as Property
      return {
        success: true,
        data: {
          isDuplicate: true,
          isUserProperty: existingProperty.owner_id === session.user.id,
          existingProperty,
        },
      }
    }

    return {
      success: true,
      data: {
        isDuplicate: false,
      },
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to check for duplicates',
    }
  }
}

/**
 * Fetch public properties for community hub
 */
export async function getPublicProperties(): Promise<ActionResult<Property[]>> {
  try {
    const supabase = await createServerSupabaseClient()

    const { data, error } = await supabase
      .from('properties')
      .select(`
        *,
        address:properties_addresses(*)
      `)
      .eq('is_private', false)
      .order('views', { ascending: false })
      .limit(50)

    if (error) {
      return {
        success: false,
        error: error.message,
        data: [],
      }
    }

    return {
      success: true,
      data: data as Property[],
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to fetch public properties',
      data: [],
    }
  }
}

/**
 * Get a property model for viewing
 * Allows viewing if: property is public OR user owns the property
 */
export async function getPropertyModelPublic(propertyId: string): Promise<
  ActionResult<{ property: Property; model: any | null }>
> {
  try {
    const session = await getSession()
    const supabase = await createServerSupabaseClient()

    // Get the property (without privacy filter first)
    const { data: property, error: propertyError } = await supabase
      .from('properties')
      .select(`
        *,
        address:properties_addresses(*)
      `)
      .eq('id', propertyId)
      .single()

    if (propertyError || !property) {
      return {
        success: false,
        error: 'Property not found',
        data: undefined,
      }
    }

    // Check if user can view this property
    // Allow if: property is public OR user owns it
    const propertyData = property as any
    const isOwner = session?.user && propertyData.owner_id === session.user.id
    const isPublic = propertyData.is_private === false

    if (!isPublic && !isOwner) {
      return {
        success: false,
        error: 'Property is private',
        data: undefined,
      }
    }

    // Get the model
    const { data: model } = await supabase
      .from('properties_models')
      .select('*')
      .eq('property_id', propertyId)
      .is('deleted_at', null)
      .order('version', { ascending: false })
      .limit(1)
      .maybeSingle()

    return {
      success: true,
      data: {
        property: propertyData as Property,
        model: model || null,
      },
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to fetch property',
      data: undefined,
    }
  }
}

/**
 * Increment property view count
 */
export async function incrementPropertyViews(propertyId: string): Promise<ActionResult> {
  try {
    const supabase = await createServerSupabaseClient()

    const { error } = await supabase.rpc('increment_property_views', {
      property_id: propertyId,
    } as any)

    if (error) {
      console.error('Failed to increment views:', error)
      // Don't fail the request if view increment fails
    }

    return { success: true }
  } catch (error) {
    console.error('Failed to increment views:', error)
    return { success: true } // Don't fail on view tracking errors
  }
}

/**
 * Update property privacy setting
 */
export async function updatePropertyPrivacy(
  propertyId: string,
  isPrivate: boolean,
): Promise<ActionResult> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
      }
    }

    const supabase = await createServerSupabaseClient()

    // Verify ownership
    const { data: property } = await supabase
      .from('properties')
      .select('owner_id')
      .eq('id', propertyId)
      .single()

    if ((property as any)?.owner_id !== session.user.id) {
      return {
        success: false,
        error: 'Unauthorized',
      }
    }

    // Update privacy
    const { error } = await (supabase
      .from('properties') as any)
      .update({ is_private: isPrivate })
      .eq('id', propertyId)

    if (error) {
      return {
        success: false,
        error: error.message,
      }
    }

    return {
      success: true,
      message: `Property is now ${isPrivate ? 'private' : 'public'}`,
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to update property privacy',
    }
  }
}

/**
 * Update property address
 */
export async function updatePropertyAddress(
  propertyId: string,
  addressData: {
    street_number?: string
    route?: string
    city?: string
    state?: string
    postal_code?: string
    country?: string
  },
): Promise<ActionResult> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
      }
    }

    const supabase = await createServerSupabaseClient()

    // Verify ownership and get address_id
    const { data: property } = await supabase
      .from('properties')
      .select('owner_id, address_id')
      .eq('id', propertyId)
      .single()

    if (!property) {
      return {
        success: false,
        error: 'Property not found',
      }
    }

    if ((property as any).owner_id !== session.user.id) {
      return {
        success: false,
        error: 'Unauthorized',
      }
    }

    // Update address
    const { error } = await (supabase
      .from('properties_addresses') as any)
      .update(addressData)
      .eq('id', (property as any).address_id)

    if (error) {
      return {
        success: false,
        error: error.message,
      }
    }

    return {
      success: true,
      message: 'Address updated successfully',
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to update address',
    }
  }
}

/**
 * Migrate a local property to the cloud
 * Creates a new property with the local property's data
 */
export async function migrateLocalProperty(
  localProperty: {
    name: string
    scene_graph: any
  },
): Promise<ActionResult<{ id: string }>> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
      }
    }

    const supabase = await createServerSupabaseClient()

    // Create a default address (user can edit later via settings)
    const addressId = createId('address')
    const { error: addressError } = await (supabase.from('properties_addresses') as any).insert({
      id: addressId,
      country: 'US',
    })

    if (addressError) {
      return {
        success: false,
        error: addressError.message,
      }
    }

    // Create the property
    const propertyId = createId('property')
    const { error: propertyError } = await (supabase.from('properties') as any).insert({
      id: propertyId,
      name: localProperty.name,
      owner_id: session.user.id,
      address_id: addressId,
      is_private: true, // Default to private
    })

    if (propertyError) {
      return {
        success: false,
        error: propertyError.message,
      }
    }

    // Create the model with the scene graph
    if (localProperty.scene_graph) {
      const modelId = createId('model')
      const { error: modelError } = await (supabase.from('properties_models') as any).insert({
        id: modelId,
        property_id: propertyId,
        version: 1,
        scene_graph: localProperty.scene_graph,
      })

      if (modelError) {
        return {
          success: false,
          error: modelError.message,
        }
      }
    }

    return {
      success: true,
      data: { id: propertyId },
      message: 'Property migrated successfully',
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to migrate property',
    }
  }
}

/**
 * Delete a property
 * Only the owner can delete their property
 */
export async function deleteProperty(propertyId: string): Promise<ActionResult> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
      }
    }

    const supabase = await createServerSupabaseClient()

    // Verify ownership
    const { data: property } = await supabase
      .from('properties')
      .select('owner_id')
      .eq('id', propertyId)
      .single()

    if (!property) {
      return {
        success: false,
        error: 'Property not found',
      }
    }

    if ((property as any).owner_id !== session.user.id) {
      return {
        success: false,
        error: 'Unauthorized',
      }
    }

    // Delete the property (cascade will delete related records)
    const { error } = await supabase.from('properties').delete().eq('id', propertyId)

    if (error) {
      return {
        success: false,
        error: error.message,
      }
    }

    return {
      success: true,
      message: 'Property deleted successfully',
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to delete property',
    }
  }
}

/**
 * Check if the current user has liked specific properties
 * Returns a map of propertyId -> boolean
 */
export async function getUserPropertyLikes(
  propertyIds: string[],
): Promise<ActionResult<Record<string, boolean>>> {
  try {
    const session = await getSession()

    if (!session?.user || propertyIds.length === 0) {
      // Return empty map for unauthenticated users or no properties
      return {
        success: true,
        data: {},
      }
    }

    const supabase = await createServerSupabaseClient()

    const { data: likes, error } = await supabase
      .from('property_likes')
      .select('property_id')
      .eq('user_id', session.user.id)
      .in('property_id', propertyIds)

    if (error) {
      return {
        success: false,
        error: error.message,
        data: {},
      }
    }

    // Convert array to map
    const likeMap: Record<string, boolean> = {}
    propertyIds.forEach((id) => {
      likeMap[id] = likes?.some((like) => (like as any).property_id === id) || false
    })

    return {
      success: true,
      data: likeMap,
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to fetch likes',
      data: {},
    }
  }
}

/**
 * Toggle like on a property
 * Returns the new like state and updated like count
 */
export async function togglePropertyLike(
  propertyId: string,
): Promise<ActionResult<{ liked: boolean; likes: number }>> {
  try {
    const session = await getSession()

    if (!session?.user) {
      return {
        success: false,
        error: 'Not authenticated',
      }
    }

    const supabase = await createServerSupabaseClient()
    const userId = session.user.id

    // Check if user has already liked this property
    const { data: existingLike } = await supabase
      .from('property_likes')
      .select('id')
      .eq('property_id', propertyId)
      .eq('user_id', userId)
      .maybeSingle()

    let liked = false

    if (existingLike) {
      // Unlike - remove the like
      const { error } = await (supabase
        .from('property_likes') as any)
        .delete()
        .eq('id', (existingLike as any).id)

      if (error) {
        return {
          success: false,
          error: error.message,
        }
      }

      liked = false
    } else {
      // Like - add a new like
      const likeId = createId('like')
      const { error } = await (supabase.from('property_likes') as any).insert({
        id: likeId,
        property_id: propertyId,
        user_id: userId,
      })

      if (error) {
        return {
          success: false,
          error: error.message,
        }
      }

      liked = true
    }

    // Get updated like count
    const { data: likeCount } = await supabase.rpc('get_property_like_count', {
      property_id: propertyId,
    } as any)

    // Update the property's like count cache
    await (supabase
      .from('properties') as any)
      .update({ likes: likeCount || 0 })
      .eq('id', propertyId)

    return {
      success: true,
      data: {
        liked,
        likes: likeCount || 0,
      },
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to toggle like',
    }
  }
}

/**
 * Upload a thumbnail image to Supabase Storage and update the property
 */
export async function uploadPropertyThumbnail(
  propertyId: string,
  blob: Blob
): Promise<{ success: true; data: { thumbnail_url: string } } | { success: false; error: string }> {
  try {
    const session = await getSession()
    if (!session?.user?.id) {
      return { success: false, error: 'Not authenticated' }
    }

    // Validate file size (max 10MB)
    const MAX_SIZE = 10 * 1024 * 1024
    if (blob.size > MAX_SIZE) {
      return { success: false, error: `Image too large (${(blob.size / 1024 / 1024).toFixed(1)}MB). Maximum size is 10MB.` }
    }

    const supabase = await createServerSupabaseClient()

    // Verify the user owns this property
    const { data: property, error: propertyError } = await supabase
      .from('properties')
      .select('owner_id')
      .eq('id', propertyId)
      .single()

    if (propertyError || !property) {
      return { success: false, error: 'Property not found' }
    }

    if ((property as any).owner_id !== session.user.id) {
      return { success: false, error: 'Not authorized to update this property' }
    }

    // Generate a unique filename
    const timestamp = Date.now()
    const filename = `${propertyId}/${timestamp}.png`

    // Upload to Supabase Storage
    const { data: uploadData, error: uploadError } = await supabase.storage
      .from('property-thumbnails')
      .upload(filename, blob, {
        contentType: 'image/png',
        upsert: false,
      })

    if (uploadError) {
      return { success: false, error: `Upload failed: ${uploadError.message}` }
    }

    // Get the public URL
    const { data: urlData } = supabase.storage
      .from('property-thumbnails')
      .getPublicUrl(uploadData.path)

    const thumbnailUrl = urlData.publicUrl

    // Update the property with the new thumbnail URL
    const { error: updateError } = await (supabase
      .from('properties') as any)
      .update({ thumbnail_url: thumbnailUrl })
      .eq('id', propertyId)

    if (updateError) {
      return { success: false, error: `Failed to update property: ${updateError.message}` }
    }

    return {
      success: true,
      data: { thumbnail_url: thumbnailUrl },
    }
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to upload thumbnail',
    }
  }
}