//
//  RookSync.swift
//  RNRookSdk
//
//  Created by Javier Villanueva on 18/12/25.
//

import React
import RookSDK

@objcMembers public class RookSync: NSObject {
  lazy var summaryManager: RookSummaryManager = {
    return RookSummaryManager()
  }()
  
  lazy var eventManager: RookEventsManager = {
    return RookEventsManager()
  }()
  
  lazy var dateHelper: DateHelper = {
    return DateHelper()
  }()
  
  public func sync(_ callback: @escaping RCTResponseSenderBlock) {
    Task {
      do {
        let result = try await summaryManager.sync()
        
        DispatchQueue.main.async {
          callback([NSNull(), result])
        }
      } catch {
        var errorInfo = [
          "code": "1001",
          "message": "An error ocurred with SDK try again"
        ]
        
        if let rookError: RookError = error as? RookError {
          errorInfo["code"] = String(rookError.code)
          errorInfo["message"] = rookError.errorDescription
          
          DispatchQueue.main.async {
            callback([errorInfo, false])
          }
        } else {
          errorInfo["message"] = error.localizedDescription
          DispatchQueue.main.async {
            callback([errorInfo, false])
          }
        }
      }
    }
  }
  
  public func syncByDate(_ date: String, callback: @escaping RCTResponseSenderBlock) {
    Task {
      do {
        guard let parsed = dateHelper.getDateFromString(stringDate: date) else {
          let error: [String: Any] = [
            "code": "8",
            "message": "The provided date is not in the allowed to fetch the summary",
          ]
          
          callback([error, false])
          return
        }
        
        let result = try await summaryManager.sync(parsed)
        
        DispatchQueue.main.async {
          callback([NSNull(), result])
        }
        
      } catch {
        var errorInfo = [
          "code": "1001",
          "message": "An error ocurred with SDK try again"
        ]
        
        if let rookError: RookError = error as? RookError {
          errorInfo["code"] = String(rookError.code)
          errorInfo["message"] = rookError.errorDescription
          
          DispatchQueue.main.async {
            callback([errorInfo, false])
          }
        } else {
          errorInfo["message"] = error.localizedDescription
          DispatchQueue.main.async {
            callback([errorInfo, false])
          }
        }
      }
    }
  }
  
  public func syncByDefinition(_ summary: String, syncDate date: String, callback: @escaping RCTResponseSenderBlock) {
    Task {
      do {
        guard let parsed = dateHelper.getDateFromString(stringDate: date) else {
          let error: [String: Any] = [
            "code": "8",
            "message": "The provided date is not in the allowed to fetch the summary",
          ]

          callback([error, false])
          return
        }
        
        guard let type = RookSDK.SummaryTypeToUpload(rawValue: summary) else {
          let error: [String: Any] = [
            "code": "8",
            "message": "The provided date is not in the allowed to fetch the summary",
          ]
          
          callback([error, false])
          return
        }
        
        let result = try await summaryManager.sync(parsed, [type])
        
        DispatchQueue.main.async {
          callback([NSNull(), result])
        }
        
      } catch {
        var errorInfo = [
          "code": "1001",
          "message": "An error ocurred with SDK try again"
        ]
        
        if let rookError: RookError = error as? RookError {
          errorInfo["code"] = String(rookError.code)
          errorInfo["message"] = rookError.errorDescription
          
          DispatchQueue.main.async {
            callback([errorInfo, false])
          }
        } else {
          errorInfo["message"] = error.localizedDescription
          DispatchQueue.main.async {
            callback([errorInfo, false])
          }
        }
      }
    }
  }
  
  public func syncEvent(
    _ syncDate: String, event: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
  ) {
    guard let parsed = dateHelper.getDateFromString(stringDate: syncDate) else {
      reject("9", "The provided date is not in the allowed range to extract events.", nil)
      return
    }
    
    guard let type = RookSDK.EventTypeToUpload(rawValue: event) else {
      reject("1001", "Invalid event type", nil)
      return
    }
    
    Task {
      do {
        let result = try await eventManager.syncEvents(date: parsed, eventType: type)
        resolve(result)
      } catch {
        if let rookError: RookError = error as? RookError {
          DispatchQueue.main.async {
            reject(String(rookError.code), rookError.errorDescription, error as NSError)
          }
        } else {
          reject("1001", error.localizedDescription, error as NSError)
        }
      }
    }
    
  }
 
  public func getTodayAppleHealthSteps(
    _ resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
  ) {
    Task {
      do {
        let result = try await eventManager.getTodayStepCount()
        resolve(String(result))
      } catch {
        if let rookError: RookError = error as? RookError {
          DispatchQueue.main.async {
            reject(String(rookError.code), rookError.errorDescription, error as NSError)
          }
        } else {
          DispatchQueue.main.async {
            reject("1001", error.localizedDescription, error as NSError)
          }
        }
      }
    }
  }

  public func getTodayAppleHealthStepCountBySource(
    _ resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
  ) {
    Task {
      do {
        let result = try await eventManager.getTodayStepCountBySource()
        let mapper: StepCountBySourceMapper = StepCountBySourceMapper()
        let data: [String: Any?] = mapper.map(result)

        DispatchQueue.main.async {
          resolve(data)
        }
      } catch {
        if let rookError: RookError = error as? RookError {
          DispatchQueue.main.async {
            reject(String(rookError.code), rookError.errorDescription, error as NSError)
          }
        } else {
          DispatchQueue.main.async {
            reject("1001", error.localizedDescription, error as NSError)
          }
        }
      }
    }
  }
  
  public func syncTodayCaloriesCount(
    _ resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
  ) {
    Task {
      do {
        let result = try await eventManager.getTodayCalories()
        
        let dic = [
          "active": result.activeCalories,
          "basal": result.basalCalories,
          "total": result.totalCalories
        ]
        
        resolve(dic)
      } catch {
        if let rookError: RookError = error as? RookError {
          DispatchQueue.main.async {
            reject(String(rookError.code), rookError.errorDescription, error as NSError)
          }
        } else {
          DispatchQueue.main.async {
            reject("1001", error.localizedDescription, error as NSError)
          }
        }
      }
    }
  }
}
