/**
 * Conflict Resolution Module
 *
 * Provides strategies for detecting and resolving conflicts during sync.
 */

import type {
  BaseRecord,
  Conflict,
  ConflictType,
  ConflictStrategy,
  ConflictResolver,
} from '../types'

/**
 * Input for conflict detection
 */
export interface ConflictDetectionInput<T extends BaseRecord> {
  collectionId: string
  recordId: string | number
  localValue?: Partial<T>
  remoteValue?: Partial<T>
  baseValue?: T
  localTimestamp: number
  remoteTimestamp: number
}

/**
 * Detect if a conflict exists between local and remote changes
 */
export function detectConflict<T extends BaseRecord>(
  input: ConflictDetectionInput<T>
): Conflict<T> | null {
  const { localValue, remoteValue, baseValue, localTimestamp, remoteTimestamp } = input

  // Determine conflict type
  let type: ConflictType | null = null

  if (!baseValue) {
    // Both are inserts
    if (localValue && remoteValue) {
      type = 'insert-insert'
    }
  } else if (!localValue && remoteValue) {
    // Local deleted, remote updated
    type = 'delete-update'
  } else if (localValue && !remoteValue) {
    // Local updated, remote deleted
    type = 'update-delete'
  } else if (localValue && remoteValue) {
    // Both updated - check if same fields modified
    const localKeys = Object.keys(localValue)
    const remoteKeys = Object.keys(remoteValue)
    const conflictingKeys = localKeys.filter(k => remoteKeys.includes(k))

    // Check if any conflicting fields have different values
    const hasConflict = conflictingKeys.some(k => {
      const localVal = (localValue as Record<string, unknown>)[k]
      const remoteVal = (remoteValue as Record<string, unknown>)[k]
      const baseVal = (baseValue as Record<string, unknown>)?.[k]

      // Conflict if both changed from base and to different values
      return localVal !== baseVal && remoteVal !== baseVal && localVal !== remoteVal
    })

    if (hasConflict) {
      type = 'update-update'
    }
  }

  if (!type) return null

  const conflict: Conflict<T> = {
    type,
    collectionId: input.collectionId,
    recordId: input.recordId,
    localTimestamp,
    remoteTimestamp,
  }

  if (localValue !== undefined) {
    conflict.localValue = localValue
  }
  if (remoteValue !== undefined) {
    conflict.remoteValue = remoteValue
  }
  if (baseValue !== undefined) {
    conflict.baseValue = baseValue
  }

  return conflict
}

/**
 * Built-in conflict resolution strategies
 */
export const strategies = {
  /**
   * Local changes always win
   */
  async localWins<T extends BaseRecord>(conflict: Conflict<T>): Promise<T | null> {
    if (!conflict.localValue) return null
    const base = conflict.baseValue || {} as T
    return { ...base, ...conflict.localValue } as T
  },

  /**
   * Remote changes always win
   */
  async remoteWins<T extends BaseRecord>(conflict: Conflict<T>): Promise<T | null> {
    if (!conflict.remoteValue) return null
    const base = conflict.baseValue || {} as T
    return { ...base, ...conflict.remoteValue } as T
  },

  /**
   * Most recent timestamp wins
   */
  async latestWins<T extends BaseRecord>(conflict: Conflict<T>): Promise<T | null> {
    if (conflict.localTimestamp > conflict.remoteTimestamp) {
      return strategies.localWins(conflict)
    }
    return strategies.remoteWins(conflict)
  },

  /**
   * Merge non-conflicting fields, use latest for conflicts
   */
  async merge<T extends BaseRecord>(conflict: Conflict<T>): Promise<T | null> {
    const base = conflict.baseValue || {} as T
    const local = conflict.localValue || {}
    const remote = conflict.remoteValue || {}

    // Start with base
    const result = { ...base }

    // Get all modified keys
    const allKeys = new Set([...Object.keys(local), ...Object.keys(remote)])

    for (const key of allKeys) {
      const localVal = (local as Record<string, unknown>)[key]
      const remoteVal = (remote as Record<string, unknown>)[key]
      const baseVal = (base as Record<string, unknown>)[key]

      const localChanged = localVal !== undefined && localVal !== baseVal
      const remoteChanged = remoteVal !== undefined && remoteVal !== baseVal

      if (localChanged && remoteChanged) {
        // Both changed - use latest
        if (conflict.localTimestamp > conflict.remoteTimestamp) {
          (result as Record<string, unknown>)[key] = localVal
        } else {
          (result as Record<string, unknown>)[key] = remoteVal
        }
      } else if (localChanged) {
        (result as Record<string, unknown>)[key] = localVal
      } else if (remoteChanged) {
        (result as Record<string, unknown>)[key] = remoteVal
      }
    }

    return result as T
  },
}

/**
 * Resolve a conflict using a strategy or custom resolver
 */
export async function resolveConflict<T extends BaseRecord>(
  conflict: Conflict<T>,
  strategyOrResolver: ConflictStrategy | ConflictResolver<T>
): Promise<T | null> {
  if (typeof strategyOrResolver === 'function') {
    return strategyOrResolver(conflict)
  }

  switch (strategyOrResolver) {
    case 'local-wins':
      return strategies.localWins(conflict)
    case 'remote-wins':
      return strategies.remoteWins(conflict)
    case 'latest-wins':
      return strategies.latestWins(conflict)
    case 'merge':
      return strategies.merge(conflict)
    case 'manual':
      return null
  }
}

/**
 * Create a conflict resolver function from a strategy
 */
export function createConflictResolver<T extends BaseRecord>(
  strategy: ConflictStrategy
): ConflictResolver<T> {
  return (conflict: Conflict<T>) => resolveConflict(conflict, strategy)
}

/**
 * Builder for creating custom conflict resolvers with multiple rules
 */
export class ConflictResolverBuilder<T extends BaseRecord> {
  private _defaultStrategy: ConflictStrategy = 'latest-wins'
  private conflictTypeStrategies: Map<ConflictType, ConflictStrategy | ConflictResolver<T>> = new Map()
  private recordHandlers: Map<string | number, ConflictResolver<T>> = new Map()

  /**
   * Set the default strategy for unmatched conflicts
   */
  defaultStrategy(strategy: ConflictStrategy): this {
    this._defaultStrategy = strategy
    return this
  }

  /**
   * Set strategy for a specific conflict type
   */
  forConflictType(
    type: ConflictType,
    strategyOrResolver: ConflictStrategy | ConflictResolver<T>
  ): this {
    this.conflictTypeStrategies.set(type, strategyOrResolver)
    return this
  }

  /**
   * Set custom handler for a specific record ID
   */
  forRecord(recordId: string | number, handler: ConflictResolver<T>): this {
    this.recordHandlers.set(recordId, handler)
    return this
  }

  /**
   * Build the resolver function
   */
  build(): ConflictResolver<T> {
    return async (conflict: Conflict<T>): Promise<T | null> => {
      // Check for record-specific handler first
      const recordHandler = this.recordHandlers.get(conflict.recordId)
      if (recordHandler) {
        return recordHandler(conflict)
      }

      // Check for conflict type specific strategy
      const typeStrategy = this.conflictTypeStrategies.get(conflict.type)
      if (typeStrategy) {
        return resolveConflict(conflict, typeStrategy)
      }

      // Fall back to default strategy
      return resolveConflict(conflict, this._defaultStrategy)
    }
  }
}