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

import RookSDK
import React

@objcMembers public class RookData: NSObject {
  
  lazy var summaryManager: RookSummaryManager = {
    return RookSummaryManager()
  }()
  
  lazy var eventManager: RookEventsManager = {
    return RookEventsManager()
  }()
  
  lazy var dateHelper: DateHelper = {
    return DateHelper()
  }()
  
  public func getAppleHealthSleepSummary(
    _ date: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
  ) {
    Task {
      do {
        guard let parsed: Date = dateHelper.getDateFromString(stringDate: date) else {
          reject("AppleHealthGetPhysicalSummaryError", "Invalid date format", nil)
          return
        }

        let sleepSummaries = try await summaryManager.getSleepSummary(date: parsed)
        let dic = sleepSummaries.map { $0.toDictionary() }
        
        DispatchQueue.main.async {
          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", "An error ocurred with SDK try again", error as NSError)
          }
        }
      }
    }
  }
  
  public func getAppleHealthPhysicalSummary(
    _ date: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
  ) {
    Task {
      do {
        guard let parsed = dateHelper.getDateFromString(stringDate: date) else {
          reject("AppleHealthGetPhysicalSummaryError", "Invalid date format", nil)
          return
        }
        
        let physicalSummaries = try await summaryManager.getPhysicalSummary(date: parsed)
        let dic = physicalSummaries.toDictionary()
        
        DispatchQueue.main.async {
          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", "An error ocurred with SDK try again", error as NSError)
          }
        }
      }
    }
  }
  
  public func getAppleHealthBodySummary(
    _ date: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
  ) {
    Task {
      do {
        guard let parsed = dateHelper.getDateFromString(stringDate: date) else {
          reject("AppleHealthGetBodySummaryError", "Invalid date format", nil)
          return
        }
        let bodySummaries = try await summaryManager.getBodySummary(date: parsed)
        let dic = bodySummaries.toDictionary()
        
        DispatchQueue.main.async {
          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", "An error ocurred with SDK try again", error as NSError)
          }
        }
      }
    }
  }
  
  public func getAppleHealthActivityEvents(
    _ date: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
  ) {
    Task {
      do {
        guard let parsed = dateHelper.getDateFromString(stringDate: date) else {
          reject("AppleHealthGetActivityEventsError", "Invalid date format", nil)
          return
        }
        
        let activityEvents = try await eventManager.getActivityEvents(date: parsed)
        let dic = activityEvents.map { $0.toDictionary() }
        
        DispatchQueue.main.async {
          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", "An error ocurred with SDK try again", error as NSError)
          }
        }
      }
    }
  }
  
  public func getTodayHeartRate(
     _ resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
   ){
     Task {
       do {
         let result = try await eventManager.getTodayHeartRate()
         let mapper: HeartRateMapper = HeartRateMapper()
         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 {
           reject("1001", "An error ocurred with SDK try again", error as NSError)
         }
       }
     }
   }
  
  public func writeAppleHealthMealData(
     _ data: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock
   ){
     guard let event = NutritionMapper.mapToNutritionInsertionEvent(data: data as! [String : Any]) else {
       reject("1001", "Could not parse nutrition data", nil)
       return
     }
     
     Task {
       do {
        
         let result = try await eventManager.writeNutritionEvent(event: event)
         DispatchQueue.main.async {
           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", "An error ocurred with SDK try again", error as NSError)
         }
       }
     }
   }
  
}
