CoreDataのスレッドを使用するように修正

[kcd/KCD.git] / KCD / GuardShelterCommand.swift

diff --git a/KCD/GuardShelterCommand.swift b/KCD/GuardShelterCommand.swift
index 0134ef4..d1d1266 100644 (file)
--- a/KCD/GuardShelterCommand.swift
+++ b/KCD/GuardShelterCommand.swift
@@ -8,105 +8,108 @@
 
 import Cocoa
 
-
-enum GuardEscapeAPI: String {
-    
-    case goback = "/kcsapi/api_req_combined_battle/goback_port"
-}
-
 extension Notification.Name {
     
     static let DidUpdateGuardEscape = Notification.Name("com.masakih.KCD.Notification.DidUpdateGuardEscape")
 }
 
 final class GuardShelterCommand: JSONCommand {
-    
-    override class func canExecuteAPI(_ api: String) -> Bool {
         
-        return GuardEscapeAPI(rawValue: api) != nil ? true : false
+    override class func canExecuteAPI(_ api: API) -> Bool {
+        
+        return api.type == .guardEscape
     }
     
     override func execute() {
         
-        if let b = BattleAPI(rawValue: api) {
+        switch api.type {
             
-            switch b {
-            case .battleResult, .combinedBattleResult:
-                registerReserve()
-                
-            default:
-                break
-            }
-        }
-        if let m = MapAPI(rawValue: api), m == .next {
+        case .battleResult:
+            reserveEscapeShips()
             
+        case .map:
             removeInvalidEntry()
-        }
-        if let _ = GuardEscapeAPI(rawValue: api) {
             
+        case .guardEscape:
             ensureGuardShelter()
-        }
-        if let _ = PortAPI(rawValue: api) {
             
+        case .port:
             removeAllEntry()
+            
+        default: return Logger.shared.log("Missing API: \(apiResponse.api)")
         }
     }
     
     private func damagedShipId(damagedPos: Int) -> Int? {
         
+        let tempStore = TemporaryDataStore.default
+        let firstDeckId = tempStore.sync { tempStore.battle()?.deckId ?? 1 }
+        
         let store = ServerDataStore.default
         
-        switch damagedPos {
-        case 1...6: return store.deck(by: 1)?.shipId(of: damagedPos - 1)
-        case 7...12: return store.deck(by: 2)?.shipId(of: damagedPos - 6 - 1)
-        default: return nil
+        switch firstDeckId {
+        case 1:
+            switch damagedPos {
+            case 1...6: return store.sync { store.deck(by: 1)?.shipId(of: damagedPos - 1) }
+            case 7...12: return store.sync { store.deck(by: 2)?.shipId(of: damagedPos - 6 - 1) }
+            default: return nil
+            }
+        case 3:
+            return store.sync { store.deck(by: 3)?.shipId(of: damagedPos - 1) }
+        default:
+            return nil
         }
     }
     
-    private func registerReserve() {
+    private func reserveEscapeShips() {
         
         let escape = data["api_escape"]
         
-        guard let guardianPos = escape["api_tow_idx"][0].int else { return }
+        guard let escapeIdx = escape["api_escape_idx"][0].int else { return }
+        guard let damagedId = damagedShipId(damagedPos: escapeIdx) else {
+            
+            return  Logger.shared.log("damagedPos is wrong")
+        }
         
-        let fixedGuardianPos = guardianPos - 6 - 1
+        let store = TemporaryDataStore.oneTimeEditor()
+        store.sync {
+            
+            guard let damaged = store.createGuardEscaped() else {
                 
-        guard let guardianId = ServerDataStore.default.deck(by: 2)?.shipId(of: fixedGuardianPos) else {
+                return Logger.shared.log("Can not create GuardEscaped for damaged")
+            }
+            
+            damaged.shipID = damagedId
+            damaged.ensured = false
+            
+            // store guardian if needs
+            guard let guardianPos = escape["api_tow_idx"][0].int else { return }
+            
+            let fixedGuardianPos = guardianPos - 6 - 1
+            
+            let sStore = ServerDataStore.default
+            guard let guardianId = sStore.sync(execute: { sStore.deck(by: 2)?.shipId(of: fixedGuardianPos) }) else {
                 
                 return Logger.shared.log("guardianPos is wrong")
-        }
-        
-        guard let escapeIdx = escape["api_escape_idx"][0].int,
-            let damagedId = damagedShipId(damagedPos: escapeIdx) else {
-                
-                return Logger.shared.log("damagedPos is wrong")
-        }
-        
-        let store = TemporaryDataStore.oneTimeEditor()
-        
-        guard let guardian = store.createGuardEscaped() else {
+            }
             
-            return Logger.shared.log("Can not create GuardEscaped for guardinan")
-        }
-        
-        guardian.shipID = guardianId
-        guardian.ensured = false
-        
-        guard let damaged = store.createGuardEscaped() else {
+            guard let guardian = store.createGuardEscaped() else {
+                
+                return Logger.shared.log("Can not create GuardEscaped for guardinan")
+            }
             
-            return Logger.shared.log("Can not create GuardEscaped for damaged")
+            guardian.shipID = guardianId
+            guardian.ensured = false
         }
-        
-        damaged.shipID = damagedId
-        damaged.ensured = false
     }
     
     private func removeInvalidEntry() {
         
         let store = TemporaryDataStore.oneTimeEditor()
-        
-        store.notEnsuredGuardEscaped().forEach(store.delete)
-        store.save(errorHandler: store.presentOnMainThread)
+        store.sync {
+            store.notEnsuredGuardEscaped().forEach(store.delete)
+            store.save(errorHandler: store.presentOnMainThread)
+        }
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }
@@ -114,19 +117,21 @@ final class GuardShelterCommand: JSONCommand {
     private func removeAllEntry() {
         
         let store = TemporaryDataStore.oneTimeEditor()
-        
-        store.guardEscaped().forEach(store.delete)
-        store.save(errorHandler: store.presentOnMainThread)
+        store.sync {
+            store.guardEscaped().forEach(store.delete)
+            store.save(errorHandler: store.presentOnMainThread)
+        }
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }
     
-    func ensureGuardShelter() {
+    private func ensureGuardShelter() {
         
         let store = TemporaryDataStore.oneTimeEditor()
-        
-        store.guardEscaped().forEach { $0.ensured = true }
-        store.save(errorHandler: store.presentOnMainThread)
+        store.sync {
+            store.guardEscaped().forEach { $0.ensured = true }
+            store.save(errorHandler: store.presentOnMainThread)
+        }
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }