KCD/TSVSupport.swift

   1 //
   2 //  File.swift
   3 //  KCD
   4 //
   5 //  Created by Hori,Masaki on 2017/02/05.
   6 //  Copyright © 2017年 Hori,Masaki. All rights reserved.
   7 //
   8
   9 import Cocoa
  10
  11 fileprivate struct LFSeparateLine {
  12
  13     static let empty = LFSeparateLine(line: "", empty: true)
  14
  15     let line: String
  16
  17     private let isEmpty: Bool
  18
  19     init(line: String, empty: Bool = false) {
  20
  21         self.line = line
  22         isEmpty = empty
  23     }
  24
  25     func append(_ column: String) -> LFSeparateLine {
  26
  27         if isEmpty { return LFSeparateLine(line: column) }
  28
  29         let newLine = line + "\t" + column
  30
  31         return LFSeparateLine(line: newLine)
  32     }
  33
  34     func append(_ dateCol: Date) -> LFSeparateLine {
  35
  36         return append("\(dateCol)")
  37     }
  38
  39     func append(_ intCol: Int) -> LFSeparateLine {
  40
  41         return append("\(intCol)")
  42     }
  43
  44     func append(_ boolCol: Bool) -> LFSeparateLine {
  45
  46         return append("\(boolCol)")
  47     }
  48 }
  49
  50 // swiftlint:disable type_body_length
  51 final class TSVSupport {
  52
  53     private let store = LocalDataStore.oneTimeEditor()
  54
  55     private var dateFomatter: DateFormatter = {
  56
  57         let formatter = DateFormatter()
  58         formatter.dateFormat = "yyyy'-'MM'-'dd' 'HH':'mm':'ss' 'Z"
  59         return formatter
  60     }()
  61
  62     func load() {
  63
  64         let panel = NSOpenPanel()
  65         panel.allowedFileTypes = ["kcdlocaldata"]
  66         panel.begin {
  67
  68             guard $0 == NSModalResponseOK
  69                 else { return }
  70
  71             panel.urls.forEach { url in
  72
  73                 guard let fileW = try? FileWrapper(url: url)
  74                     else { return }
  75
  76                 fileW.fileWrappers?.forEach {
  77
  78                     guard let data = $0.value.regularFileContents
  79                         else { return }
  80
  81                     switch $0.key {
  82                     case "kaihatu.tsv": self.registerKaihatuHistory(data)
  83                     case "kenzo.tsv": self.registerKenzoHistory(data)
  84                     case "kenzoMark.tsv": self.registerKenzoMark(data)
  85                     case "dropShip.tsv": self.registerDropShipHistory(data)
  86                     default: break
  87                     }
  88                 }
  89
  90             }
  91         }
  92     }
  93
  94     func save() {
  95
  96         let panel = NSSavePanel()
  97         panel.allowedFileTypes = ["kcdlocaldata"]
  98         panel.begin {
  99
 100             guard $0 == NSModalResponseOK,
 101                 let url = panel.url
 102                 else { return }
 103             guard let kaihatuHistory = self.dataOfKaihatuHistory(),
 104                 let kenzoHistory = self.dataOfKenzoHistory(),
 105                 let kenzoMark = self.dataOfKenzoMark(),
 106                 let dropShipHistory = self.dataOfDropShipHistory()
 107                 else { return }
 108
 109             let fileW = FileWrapper(directoryWithFileWrappers: [:])
 110             fileW.addRegularFile(withContents: kaihatuHistory, preferredFilename: "kaihatu.tsv")
 111             fileW.addRegularFile(withContents: kenzoHistory, preferredFilename: "kenzo.tsv")
 112             fileW.addRegularFile(withContents: kenzoMark, preferredFilename: "kenzoMark.tsv")
 113             fileW.addRegularFile(withContents: dropShipHistory, preferredFilename: "dropShip.tsv")
 114             do {
 115
 116                 try fileW.write(to: url, originalContentsURL: nil)
 117
 118             } catch {
 119
 120                 print("Error to write")
 121             }
 122         }
 123     }
 124
 125     private func localData<T>(_ entity: Entity<T>, sortBy: String = "date") -> [T] {
 126
 127         let sortDesc = NSSortDescriptor(key: sortBy, ascending: true)
 128
 129         guard let array = try? store.objects(of: entity, sortDescriptors: [sortDesc])
 130             else {
 131                 print("Can not get \(entity.name)")
 132                 return []
 133         }
 134
 135         return array
 136     }
 137
 138     private func dataOfKaihatuHistory() -> Data? {
 139
 140         return localData(KaihatuHistory.entity)
 141             .map {
 142                 LFSeparateLine.empty
 143                     .append($0.date)
 144                     .append($0.fuel)
 145                     .append($0.bull)
 146                     .append($0.steel)
 147                     .append($0.bauxite)
 148                     .append($0.kaihatusizai)
 149                     .append($0.name)
 150                     .append($0.flagShipName)
 151                     .append($0.flagShipLv)
 152                     .append($0.commanderLv)
 153                     .line
 154             }
 155             .joined(separator: "\n")
 156             .data(using: .utf8)
 157     }
 158
 159     private func dataOfKenzoHistory() -> Data? {
 160
 161         return localData(KenzoHistory.entity)
 162             .map {
 163             LFSeparateLine.empty
 164                 .append($0.date)
 165                 .append($0.fuel)
 166                 .append($0.bull)
 167                 .append($0.steel)
 168                 .append($0.bauxite)
 169                 .append($0.kaihatusizai)
 170                 .append($0.name)
 171                 .append($0.sTypeId)
 172                 .append($0.flagShipName)
 173                 .append($0.flagShipLv)
 174                 .append($0.commanderLv)
 175                 .line
 176             }
 177             .joined(separator: "\n")
 178             .data(using: .utf8)
 179     }
 180
 181     private func dataOfKenzoMark() -> Data? {
 182
 183         return localData(KenzoMark.entity, sortBy: "kDockId")
 184             .map {
 185             LFSeparateLine.empty
 186                 .append($0.date)
 187                 .append($0.fuel)
 188                 .append($0.bull)
 189                 .append($0.steel)
 190                 .append($0.bauxite)
 191                 .append($0.kaihatusizai)
 192                 .append($0.created_ship_id)
 193                 .append($0.kDockId)
 194                 .append($0.flagShipName)
 195                 .append($0.flagShipLv)
 196                 .append($0.commanderLv)
 197                 .line
 198             }
 199             .joined(separator: "\n")
 200             .data(using: .utf8)
 201     }
 202
 203     private func dataOfDropShipHistory() -> Data? {
 204
 205         return localData(DropShipHistory.entity)
 206             .map {
 207                 LFSeparateLine.empty
 208                     .append($0.date)
 209                     .append($0.shipName)
 210                     .append($0.mapArea)
 211                     .append($0.mapInfo)
 212                     .append($0.mapCell)
 213                     .append($0.mapAreaName)
 214                     .append($0.mapInfoName)
 215                     .append($0.mark)
 216                     .append($0.winRank)
 217                     .line
 218             }
 219             .joined(separator: "\n")
 220             .data(using: .utf8)
 221     }
 222
 223     private func registerKaihatuHistory(_ data: Data) {
 224
 225         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 226         let store = LocalDataStore.oneTimeEditor()
 227         array?.forEach {
 228
 229             let attr = $0.components(separatedBy: "\t")
 230
 231             guard attr.count == 10,
 232                 let date = dateFomatter.date(from: attr[0]),
 233                 let fuel = Int(attr[1]),
 234                 let bull = Int(attr[2]),
 235                 let steel = Int(attr[3]),
 236                 let bauxite = Int(attr[4]),
 237                 let kaihatu = Int(attr[5]),
 238                 let flagLv = Int(attr[8]),
 239                 let commandLv = Int(attr[9])
 240                 else { return }
 241
 242             let p = NSPredicate(format: "date = %@", argumentArray: [date])
 243
 244             guard let oo = try? store.objects(of: KaihatuHistory.entity, predicate: p),
 245                 oo.count != 0
 246                 else { return }
 247
 248             guard let obj = store.insertNewObject(for: KaihatuHistory.entity)
 249                 else { return }
 250
 251             obj.date = date
 252             obj.fuel = fuel
 253             obj.bull = bull
 254             obj.steel = steel
 255             obj.bauxite = bauxite
 256             obj.kaihatusizai = kaihatu
 257             obj.name = attr[6]
 258             obj.flagShipName = attr[7]
 259             obj.flagShipLv = flagLv
 260             obj.commanderLv = commandLv
 261         }
 262     }
 263
 264     private func registerKenzoHistory(_ data: Data) {
 265
 266         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 267         let store = LocalDataStore.oneTimeEditor()
 268
 269         array?.forEach {
 270
 271             let attr = $0.components(separatedBy: "\t")
 272
 273             guard attr.count == 11,
 274                 let date = dateFomatter.date(from: attr[0]),
 275                 let fuel = Int(attr[1]),
 276                 let bull = Int(attr[2]),
 277                 let steel = Int(attr[3]),
 278                 let bauxite = Int(attr[4]),
 279                 let kaihatu = Int(attr[5]),
 280                 let sType = Int(attr[7]),
 281                 let flagLv = Int(attr[9]),
 282                 let commandLv = Int(attr[10])
 283                 else { return }
 284
 285             let p = NSPredicate(format: "date = %@", argumentArray: [date])
 286
 287             guard let oo = try? store.objects(of: KenzoHistory.entity, predicate: p),
 288                 oo.count != 0
 289                 else { return }
 290
 291             guard let obj = store.insertNewObject(for: KenzoHistory.entity)
 292                 else { return }
 293
 294             obj.date = date
 295             obj.fuel = fuel
 296             obj.bull = bull
 297             obj.steel = steel
 298             obj.bauxite = bauxite
 299             obj.kaihatusizai = kaihatu
 300             obj.name = attr[6]
 301             obj.sTypeId = sType
 302             obj.flagShipName = attr[8]
 303             obj.flagShipLv = flagLv
 304             obj.commanderLv = commandLv
 305         }
 306     }
 307
 308     private func registerKenzoMark( _ data: Data) {
 309
 310         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 311         let store = LocalDataStore.oneTimeEditor()
 312
 313         array?.forEach {
 314
 315             let attr = $0.components(separatedBy: "\t")
 316
 317             guard attr.count == 11,
 318                 let date = dateFomatter.date(from: attr[0]),
 319                 let fuel = Int(attr[1]),
 320                 let bull = Int(attr[2]),
 321                 let steel = Int(attr[3]),
 322                 let bauxite = Int(attr[4]),
 323                 let kaihatu = Int(attr[5]),
 324                 let shiId = Int(attr[6]),
 325                 let kDock = Int(attr[7]),
 326                 let flagLv = Int(attr[9]),
 327                 let commandLv = Int(attr[10])
 328                 else { return }
 329
 330             let p = NSPredicate(format: "date = %@", argumentArray: [date])
 331
 332             guard let oo = try? store.objects(of: KenzoMark.entity, predicate: p),
 333                 oo.count != 0
 334                 else { return }
 335
 336             guard let obj = store.insertNewObject(for: KenzoMark.entity)
 337                 else { return }
 338
 339             obj.date = date
 340             obj.fuel = fuel
 341             obj.bull = bull
 342             obj.steel = steel
 343             obj.bauxite = bauxite
 344             obj.kaihatusizai = kaihatu
 345             obj.created_ship_id = shiId
 346             obj.kDockId = kDock
 347             obj.flagShipName = attr[8]
 348             obj.flagShipLv = flagLv
 349             obj.commanderLv = commandLv
 350         }
 351     }
 352
 353     private func registerDropShipHistory( _ data: Data) {
 354
 355         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 356         let store = LocalDataStore.oneTimeEditor()
 357
 358         array?.forEach {
 359
 360             let attr = $0.components(separatedBy: "\t")
 361
 362             guard attr.count == 9,
 363                 let date = dateFomatter.date(from: attr[0]),
 364                 let mapInfo = Int(attr[3]),
 365                 let mapCell = Int(attr[4]),
 366                 let mark = Int(attr[7])
 367                 else { return }
 368
 369             let p = NSPredicate(format: "date = %@", argumentArray: [date])
 370
 371             guard let oo = try? store.objects(of: DropShipHistory.entity, predicate: p),
 372                 oo.count != 0
 373                 else { return }
 374
 375             guard let obj = store.insertNewObject(for: DropShipHistory.entity)
 376                 else { return }
 377
 378             obj.date = date
 379             obj.shipName = attr[1]
 380             obj.mapArea = attr[2]
 381             obj.mapInfo = mapInfo
 382             obj.mapCell = mapCell
 383             obj.mapAreaName = attr[5]
 384             obj.mapInfoName = attr[6]
 385             obj.mark = mark != 0
 386             obj.winRank = attr[8]
 387         }
 388     }
 389 }