//
//  PointsHistoryModel.swift
//  SwiftWarplyFramework
//
//  Created by Warply on 25/06/2025.
//  Copyright © 2025 Warply. All rights reserved.
//

import Foundation

// MARK: - Points History Model

public class PointsHistoryModel {
    
    // MARK: - Properties
    
    public var entryId: String?
    public var entryDate: Date?
    public var entryType: String? // "earned", "spent", "expired", "bonus", "refund"
    public var pointsAmount: Int?
    public var pointsBalance: Int?
    public var source: String? // "purchase", "bonus", "referral", "campaign", "manual"
    public var description: String?
    public var expirationDate: Date?
    public var transactionId: String?
    public var campaignId: String?
    public var couponId: String?
    public var merchantName: String?
    public var merchantId: String?
    public var productName: String?
    public var productId: String?
    public var category: String?
    public var reference: String?
    public var status: String?
    
    // MARK: - Computed Properties
    
    /// Formatted entry date
    public var formattedDate: String? {
        guard let date = entryDate else { return nil }
        let formatter = DateFormatter()
        formatter.dateStyle = .medium
        formatter.timeStyle = .short
        return formatter.string(from: date)
    }
    
    /// Formatted expiration date
    public var formattedExpirationDate: String? {
        guard let date = expirationDate else { return nil }
        let formatter = DateFormatter()
        formatter.dateStyle = .medium
        return formatter.string(from: date)
    }
    
    /// Entry type display name
    public var entryTypeDisplayName: String {
        guard let type = entryType?.lowercased() else { return "Unknown" }
        
        switch type {
        case "earned":
            return "Points Earned"
        case "spent":
            return "Points Spent"
        case "expired":
            return "Points Expired"
        case "bonus":
            return "Bonus Points"
        case "refund":
            return "Points Refunded"
        case "adjustment":
            return "Points Adjustment"
        case "transfer":
            return "Points Transfer"
        case "redemption":
            return "Points Redemption"
        default:
            return type.capitalized
        }
    }
    
    /// Source display name
    public var sourceDisplayName: String {
        guard let source = source?.lowercased() else { return "Unknown" }
        
        switch source {
        case "purchase":
            return "Purchase"
        case "bonus":
            return "Bonus"
        case "referral":
            return "Referral"
        case "campaign":
            return "Campaign"
        case "manual":
            return "Manual Adjustment"
        case "signup":
            return "Sign Up Bonus"
        case "birthday":
            return "Birthday Bonus"
        case "review":
            return "Review Bonus"
        case "social":
            return "Social Media"
        case "promotion":
            return "Promotion"
        default:
            return source.capitalized
        }
    }
    
    /// Status display name
    public var statusDisplayName: String {
        guard let status = status?.lowercased() else { return "Completed" }
        
        switch status {
        case "completed", "success":
            return "Completed"
        case "pending":
            return "Pending"
        case "failed", "error":
            return "Failed"
        case "cancelled", "canceled":
            return "Cancelled"
        case "expired":
            return "Expired"
        case "reversed":
            return "Reversed"
        default:
            return status.capitalized
        }
    }
    
    /// Formatted points amount with sign
    public var formattedPointsAmount: String {
        guard let amount = pointsAmount else { return "0" }
        
        let formatter = NumberFormatter()
        formatter.numberStyle = .decimal
        formatter.positivePrefix = "+"
        formatter.negativePrefix = "-"
        
        return formatter.string(from: NSNumber(value: amount)) ?? "\(amount)"
    }
    
    /// Formatted points balance
    public var formattedPointsBalance: String {
        guard let balance = pointsBalance else { return "0" }
        
        let formatter = NumberFormatter()
        formatter.numberStyle = .decimal
        
        return formatter.string(from: NSNumber(value: balance)) ?? "\(balance)"
    }
    
    /// Whether this entry is positive (earned points)
    public var isPositive: Bool {
        guard let amount = pointsAmount else { return false }
        return amount > 0
    }
    
    /// Whether this entry is negative (spent/expired points)
    public var isNegative: Bool {
        guard let amount = pointsAmount else { return false }
        return amount < 0
    }
    
    /// Whether points are expired or will expire soon
    public var isExpiredOrExpiring: Bool {
        guard let expirationDate = expirationDate else { return false }
        
        // Check if expired or expiring within 30 days
        let thirtyDaysFromNow = Calendar.current.date(byAdding: .day, value: 30, to: Date()) ?? Date()
        return expirationDate <= thirtyDaysFromNow
    }
    
    /// Days until expiration (negative if expired)
    public var daysUntilExpiration: Int? {
        guard let expirationDate = expirationDate else { return nil }
        
        let calendar = Calendar.current
        let components = calendar.dateComponents([.day], from: Date(), to: expirationDate)
        return components.day
    }
    
    // MARK: - Initialization
    
    public init() {
        // Empty initializer
    }
    
    public init(dictionary: [String: Any]) {
        parseFromDictionary(dictionary)
    }
    
    // MARK: - Parsing
    
    private func parseFromDictionary(_ dictionary: [String: Any]) {
        // Parse entry identification
        entryId = dictionary["entry_id"] as? String ?? dictionary["id"] as? String
        reference = dictionary["reference"] as? String ?? dictionary["ref"] as? String
        
        // Parse entry details
        entryType = dictionary["entry_type"] as? String ?? dictionary["type"] as? String
        source = dictionary["source"] as? String
        status = dictionary["status"] as? String
        description = dictionary["description"] as? String ?? dictionary["desc"] as? String
        
        // Parse points information
        if let pointsAmountValue = dictionary["points_amount"] as? Int {
            pointsAmount = pointsAmountValue
        } else if let pointsAmountString = dictionary["points_amount"] as? String {
            pointsAmount = Int(pointsAmountString)
        } else if let pointsValue = dictionary["points"] as? Int {
            pointsAmount = pointsValue
        } else if let pointsString = dictionary["points"] as? String {
            pointsAmount = Int(pointsString)
        }
        
        if let pointsBalanceValue = dictionary["points_balance"] as? Int {
            pointsBalance = pointsBalanceValue
        } else if let pointsBalanceString = dictionary["points_balance"] as? String {
            pointsBalance = Int(pointsBalanceString)
        } else if let balanceValue = dictionary["balance"] as? Int {
            pointsBalance = balanceValue
        } else if let balanceString = dictionary["balance"] as? String {
            pointsBalance = Int(balanceString)
        }
        
        // Parse merchant information
        merchantName = dictionary["merchant_name"] as? String ?? dictionary["merchant"] as? String
        merchantId = dictionary["merchant_id"] as? String
        
        // Parse product information
        productName = dictionary["product_name"] as? String ?? dictionary["product"] as? String
        productId = dictionary["product_id"] as? String
        category = dictionary["category"] as? String
        
        // Parse related IDs
        transactionId = dictionary["transaction_id"] as? String
        campaignId = dictionary["campaign_id"] as? String
        couponId = dictionary["coupon_id"] as? String
        
        // Parse entry date
        if let dateString = dictionary["entry_date"] as? String {
            entryDate = parseDate(from: dateString)
        } else if let dateString = dictionary["date"] as? String {
            entryDate = parseDate(from: dateString)
        } else if let timestamp = dictionary["timestamp"] as? TimeInterval {
            entryDate = Date(timeIntervalSince1970: timestamp)
        } else if let timestampString = dictionary["timestamp"] as? String,
                  let timestampValue = Double(timestampString) {
            entryDate = Date(timeIntervalSince1970: timestampValue)
        }
        
        // Parse expiration date
        if let expirationString = dictionary["expiration_date"] as? String {
            expirationDate = parseDate(from: expirationString)
        } else if let expirationString = dictionary["expires_at"] as? String {
            expirationDate = parseDate(from: expirationString)
        } else if let expirationTimestamp = dictionary["expiration_timestamp"] as? TimeInterval {
            expirationDate = Date(timeIntervalSince1970: expirationTimestamp)
        }
    }
    
    // MARK: - Helper Methods
    
    /// Parse date from string with multiple format support
    private func parseDate(from dateString: String) -> Date? {
        let formatters = [
            "yyyy-MM-dd HH:mm:ss",
            "yyyy-MM-dd'T'HH:mm:ss.SSSZ",
            "yyyy-MM-dd'T'HH:mm:ssZ",
            "yyyy-MM-dd'T'HH:mm:ss",
            "yyyy-MM-dd",
            "dd/MM/yyyy HH:mm:ss",
            "dd/MM/yyyy",
            "MM/dd/yyyy HH:mm:ss",
            "MM/dd/yyyy",
            "dd-MM-yyyy HH:mm:ss",
            "dd-MM-yyyy"
        ]
        
        for format in formatters {
            let formatter = DateFormatter()
            formatter.dateFormat = format
            formatter.locale = Locale(identifier: "en_US_POSIX")
            
            if let date = formatter.date(from: dateString) {
                return date
            }
        }
        
        return nil
    }
    
    /// Get points entry summary for display
    public func getSummary() -> String {
        var summary = entryTypeDisplayName
        
        let formattedAmount = formattedPointsAmount
        summary += " \(formattedAmount) points"
        
        let source = sourceDisplayName
        if source != "Unknown" {
            summary += " from \(source)"
        }
        
        if let merchantName = merchantName {
            summary += " at \(merchantName)"
        }
        
        return summary
    }
    
    /// Get expiration warning text
    public func getExpirationWarning() -> String? {
        guard let days = daysUntilExpiration else { return nil }
        
        if days < 0 {
            return "Expired \(abs(days)) days ago"
        } else if days == 0 {
            return "Expires today"
        } else if days <= 7 {
            return "Expires in \(days) day\(days == 1 ? "" : "s")"
        } else if days <= 30 {
            return "Expires in \(days) days"
        }
        
        return nil
    }
    
    /// Check if entry matches search criteria
    public func matches(searchText: String) -> Bool {
        let searchLower = searchText.lowercased()
        
        let searchableFields = [
            entryId,
            description,
            merchantName,
            productName,
            category,
            source,
            reference,
            entryType
        ].compactMap { $0?.lowercased() }
        
        return searchableFields.contains { $0.contains(searchLower) }
    }
    
    // MARK: - Dictionary Conversion
    
    /// Convert points history model to dictionary for API requests
    public func toDictionary() -> [String: Any] {
        var dictionary: [String: Any] = [:]
        
        if let entryId = entryId { dictionary["entry_id"] = entryId }
        if let entryType = entryType { dictionary["entry_type"] = entryType }
        if let pointsAmount = pointsAmount { dictionary["points_amount"] = pointsAmount }
        if let pointsBalance = pointsBalance { dictionary["points_balance"] = pointsBalance }
        if let source = source { dictionary["source"] = source }
        if let description = description { dictionary["description"] = description }
        if let merchantName = merchantName { dictionary["merchant_name"] = merchantName }
        if let merchantId = merchantId { dictionary["merchant_id"] = merchantId }
        if let productName = productName { dictionary["product_name"] = productName }
        if let productId = productId { dictionary["product_id"] = productId }
        if let category = category { dictionary["category"] = category }
        if let reference = reference { dictionary["reference"] = reference }
        if let status = status { dictionary["status"] = status }
        if let transactionId = transactionId { dictionary["transaction_id"] = transactionId }
        if let campaignId = campaignId { dictionary["campaign_id"] = campaignId }
        if let couponId = couponId { dictionary["coupon_id"] = couponId }
        
        if let entryDate = entryDate {
            dictionary["timestamp"] = entryDate.timeIntervalSince1970
        }
        
        if let expirationDate = expirationDate {
            dictionary["expiration_timestamp"] = expirationDate.timeIntervalSince1970
        }
        
        return dictionary
    }
    
    // MARK: - Debug Description
    
    public var debugDescription: String {
        return """
        PointsHistoryModel {
            entryId: \(entryId ?? "nil")
            date: \(formattedDate ?? "nil")
            type: \(entryTypeDisplayName)
            amount: \(formattedPointsAmount)
            balance: \(formattedPointsBalance)
            source: \(sourceDisplayName)
            merchant: \(merchantName ?? "nil")
            product: \(productName ?? "nil")
            status: \(statusDisplayName)
            expirationDate: \(formattedExpirationDate ?? "nil")
            description: \(description ?? "nil")
        }
        """
    }
}

// MARK: - Equatable

extension PointsHistoryModel: Equatable {
    public static func == (lhs: PointsHistoryModel, rhs: PointsHistoryModel) -> Bool {
        return lhs.entryId == rhs.entryId && lhs.entryDate == rhs.entryDate
    }
}

// MARK: - Hashable

extension PointsHistoryModel: Hashable {
    public func hash(into hasher: inout Hasher) {
        hasher.combine(entryId)
        hasher.combine(entryDate)
    }
}

// MARK: - Comparable (for sorting by date)

extension PointsHistoryModel: Comparable {
    public static func < (lhs: PointsHistoryModel, rhs: PointsHistoryModel) -> Bool {
        guard let lhsDate = lhs.entryDate, let rhsDate = rhs.entryDate else {
            return false
        }
        return lhsDate < rhsDate
    }
}