import DeviceToken from '../models/DeviceToken';
import mongoose from 'mongoose';
import { humanizeClientError } from './humanReadableError';

export class DeviceTokenUtils {
  /**
   * Determine device type from user agent string
   */
  public static determineDeviceType(userAgent?: string): 'ios' | 'android' | 'web' {
    if (!userAgent) return 'web';

    const ua = userAgent.toLowerCase();

    // Check for iOS devices
    if (ua.includes('iphone') || ua.includes('ipad') || ua.includes('ipod')) {
      return 'ios';
    }

    // Check for Android devices
    if (ua.includes('android')) {
      return 'android';
    }

    // Default to web
    return 'web';
  }

  /**
   * Update or create device token for a user
   */
  public static async upsertDeviceToken(
    userId: string | mongoose.Types.ObjectId,
    deviceToken: string,
    deviceType?: 'ios' | 'android' | 'web',
    userAgent?: string
  ): Promise<{ success: boolean; message: string }> {
    try {
      if (!deviceToken || deviceToken.trim() === '') {
        return {
          success: false,
          message: 'Device token is required',
        };
      }

      // Determine device type if not provided
      const finalDeviceType = deviceType || this.determineDeviceType(userAgent);

      // Check if device token already exists for this user
      const existingToken = await DeviceToken.findOne({
        userId,
        deviceToken: deviceToken.trim(),
      });

      if (existingToken) {
        // Update existing token
        existingToken.isActive = true;
        existingToken.lastUsed = new Date();
        existingToken.deviceType = finalDeviceType;
        await existingToken.save();

        return {
          success: true,
          message: 'Device token updated successfully',
        };
      }

      // Create new device token record
      await DeviceToken.create({
        userId,
        deviceToken: deviceToken.trim(),
        deviceType: finalDeviceType,
        isActive: true,
        lastUsed: new Date(),
      });

      return {
        success: true,
        message: 'Device token created successfully',
      };
    } catch (error: any) {
      console.error('Error upserting device token:', error);
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not save this device for notifications. Please try again.'
        ),
      };
    }
  }

  /**
   * Get all active device tokens for a user
   */
  public static async getUserDeviceTokens(
    userId: string | mongoose.Types.ObjectId
  ): Promise<any[]> {
    try {
      const tokens = await DeviceToken.find({
        userId,
        isActive: true,
      }).sort({ lastUsed: -1 });

      return tokens;
    } catch (error) {
      console.error('Error fetching user device tokens:', error);
      return [];
    }
  }

  /**
   * Deactivate a specific device token
   */
  public static async deactivateDeviceToken(
    userId: string | mongoose.Types.ObjectId,
    deviceToken: string
  ): Promise<{ success: boolean; message: string }> {
    try {
      const result = await DeviceToken.findOneAndUpdate(
        { userId, deviceToken },
        { isActive: false },
        { new: true }
      );

      if (!result) {
        return {
          success: false,
          message: 'Device token not found',
        };
      }

      return {
        success: true,
        message: 'Device token deactivated successfully',
      };
    } catch (error: any) {
      console.error('Error deactivating device token:', error);
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not turn off notifications for this device. Please try again.'
        ),
      };
    }
  }

  /**
   * Deactivate all device tokens for a user (useful for logout all devices)
   */
  public static async deactivateAllUserTokens(
    userId: string | mongoose.Types.ObjectId
  ): Promise<{ success: boolean; message: string; count: number }> {
    try {
      const result = await DeviceToken.updateMany(
        { userId, isActive: true },
        { isActive: false }
      );

      return {
        success: true,
        message: 'All device tokens deactivated successfully',
        count: result.modifiedCount,
      };
    } catch (error: any) {
      console.error('Error deactivating all device tokens:', error);
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not turn off notifications for these devices. Please try again.'
        ),
        count: 0,
      };
    }
  }

  /**
   * Clean up old inactive device tokens (older than 90 days)
   */
  public static async cleanupOldTokens(): Promise<{
    success: boolean;
    message: string;
    deletedCount: number;
  }> {
    try {
      const ninetyDaysAgo = new Date();
      ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90);

      const result = await DeviceToken.deleteMany({
        isActive: false,
        lastUsed: { $lt: ninetyDaysAgo },
      });

      return {
        success: true,
        message: `Cleaned up ${result.deletedCount} old device tokens`,
        deletedCount: result.deletedCount,
      };
    } catch (error: any) {
      console.error('Error cleaning up old device tokens:', error);
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not clean up old device tokens. Please try again.'
        ),
        deletedCount: 0,
      };
    }
  }

  /**
   * Get device token statistics for a user
   */
  public static async getUserTokenStats(
    userId: string | mongoose.Types.ObjectId
  ): Promise<{
    total: number;
    active: number;
    inactive: number;
    byDeviceType: { ios: number; android: number; web: number };
  }> {
    try {
      const tokens = await DeviceToken.find({ userId });

      const stats = {
        total: tokens.length,
        active: tokens.filter(t => t.isActive).length,
        inactive: tokens.filter(t => !t.isActive).length,
        byDeviceType: {
          ios: tokens.filter(t => t.deviceType === 'ios').length,
          android: tokens.filter(t => t.deviceType === 'android').length,
          web: tokens.filter(t => t.deviceType === 'web').length,
        },
      };

      return stats;
    } catch (error) {
      console.error('Error fetching token stats:', error);
      return {
        total: 0,
        active: 0,
        inactive: 0,
        byDeviceType: { ios: 0, android: 0, web: 0 },
      };
    }
  }
}
