eqn.ios/Sources/Earthquake Network/Models/EQNSeismic.swift

//
//  EQNSeismic.swift
//  Earthquake Network
//
//  Created by Busi Andrea on 20/09/2020.
//  Copyright © 2020 Earthquake Network. All rights reserved.
//

import Foundation


@objc class EQNSeismic: NSObject {
    
    @objc static let shared = EQNSeismic()
    
    @objc var magnitudoMinima: String
    @objc var distanzaMassima: String
    @objc var periodoTemporale: String
    @objc var sismiFortiAbilitati: Bool
    @objc var sismiFortiMagnitudo: String
    @objc var sismiQualsiasiAbilitati: Bool
    @objc var modificaImpostazioniAbilitato: Bool
    
    
    // MARK: - Init
    
    override init() {
        Self.migrateOldDistanza()
        Self.migrateOldPeriodo()
                
        magnitudoMinima = Self.userDefaults(for: EQN_MAGNITUDO_MINIMA, or: EQNData.DefaultMagitudoDebole.value)
        distanzaMassima = Self.userDefaults(for: EQN_DISTANZA_MASSIMA, or: EQNData.DefaultRaggioSisma.value)
        periodoTemporale = Self.userDefaults(for: EQN_ETA_MASSIMA, or: EQNData.DefaultPeriodoTemporale.value)
        sismiFortiAbilitati = Self.userDefaults(for: EQN_SISMI_FORTI_ABILITATI, or: false)
        sismiFortiMagnitudo = Self.userDefaults(for: EQN_SISMI_FORTI, or: EQNData.DefaultMagitudoForte.value)
        sismiQualsiasiAbilitati = Self.userDefaults(for: EQN_SISMI_QUALSIASI_MAGNITUDO, or: false)
        modificaImpostazioniAbilitato = Self.userDefaults(for: EQN_SISMI_MODIFICA_IMPOSTAZIONI, or: false)
        
        super.init()
    }
    
    
    // MARK: - Public
    
    public func saveFilters() {
        UserDefaults.standard.set(magnitudoMinima, forKey:EQN_MAGNITUDO_MINIMA)
        UserDefaults.standard.set(distanzaMassima, forKey:EQN_DISTANZA_MASSIMA)
        UserDefaults.standard.set(periodoTemporale, forKey:EQN_ETA_MASSIMA)
        UserDefaults.standard.set(sismiFortiMagnitudo, forKey:EQN_SISMI_FORTI)
        UserDefaults.standard.set(sismiFortiAbilitati, forKey:EQN_SISMI_FORTI_ABILITATI)
        UserDefaults.standard.set(sismiQualsiasiAbilitati, forKey:EQN_SISMI_QUALSIASI_MAGNITUDO)
        UserDefaults.standard.set(modificaImpostazioniAbilitato, forKey:EQN_SISMI_MODIFICA_IMPOSTAZIONI)
    }
    
    // MARK: - Private
    
    private static func userDefaults<T>(for key: String, or defaultValue: T) -> T {
        if let value = UserDefaults.standard.object(forKey: key) as? T {
            return value
        }
        return defaultValue
    }
    
    private static func migrateOldDistanza() {
        guard let savedValue = UserDefaults.standard.object(forKey: EQN_DISTANZA_MASSIMA) as? String else {
            print("[EQNSeismic] Distanza massima: nessun valore da convertire")
            return
        }
        
        if savedValue.lowercased() == NSLocalizedString("Qualsiasi distanza", comment: "").lowercased() {
            print("[EQNSeismic] Distanza massima: trovato qualsiasi distanza, salvo valore")
            UserDefaults.standard.set("100000", forKey: EQN_DISTANZA_MASSIMA)
        } else {
            print("[EQNSeismic] Distanza massima: valore da non convertire (value: \(savedValue))")

        }
    }
    
    private static func migrateOldPeriodo() {
        guard let savedValue = UserDefaults.standard.object(forKey: EQN_ETA_MASSIMA) as? String else {
            print("[EQNSeismic] Età massima: nessun valore da convertire");
            return
        }
        
        var convertedValue: String?
        if savedValue.lowercased() == NSLocalizedString("Un giorno", comment: "").lowercased() {
            convertedValue = "1440"
        } else if savedValue.lowercased() == NSLocalizedString("Dodici ore", comment: "").lowercased() {
            convertedValue = "720"
        } else if savedValue.lowercased() == NSLocalizedString("Sei ore", comment: "").lowercased() {
            convertedValue = "360"
        } else if savedValue.lowercased() == NSLocalizedString("Due ore", comment: "").lowercased() {
            convertedValue = "120"
        } else if savedValue.lowercased() == NSLocalizedString("Un ora", comment: "").lowercased() {
            convertedValue = "60"
        } else if savedValue.lowercased() == NSLocalizedString("Dieci minuti", comment: "").lowercased() {
            convertedValue = "10"
        }
        
        if let convertedValue = convertedValue {
            print("[EQNSeismic] Età massima: salvo valore convertito (old: \(savedValue) - new: \(convertedValue)")
            UserDefaults.standard.set(convertedValue, forKey: EQN_ETA_MASSIMA)
        } else {
            print("[EQNSeismic] Età massima: valore già convertito")
        }
    }
    
    // MARK: - Class
    
    @objc func filterSeismicList(_ list: [EQNSisma]) -> [EQNSisma] {
        // enti abilitati
        var networks: [String]
        if let savedNetworks = UserDefaults.standard.object(forKey: IMPOSTAZIONE_ENTI_RETI_SISMICHEI) as? [String] {
            networks = savedNetworks
        } else {
            networks = EQNData.seismicNetworkAcronyms()
        }
        networks = networks.map { $0.lowercased() }
        
        // filtri
        let filterDistance = Double(distanzaMassima)
        let filterMagnitude = Double(magnitudoMinima)
        let filterShowNear = sismiQualsiasiAbilitati
        let filterShowNearRadius: Double = 50.0
        let filterStrongEarthquake = Double(sismiFortiMagnitudo)
        let filterStrongEarthquakeEnabled = sismiFortiAbilitati
        let filterTime = Double(periodoTemporale)
        
        // filter seismic list
        var filtered = [EQNSisma]()
        for seismic in list {
            var keep = true
            
            if !networks.contains(seismic.provider.lowercased()) {
                keep = false
            }
            
            // filtro distanza massima
            if let filterDistance = filterDistance, seismic.userDistance > filterDistance {
                keep = false
            }
            
            // filtro magnitudo minima e mostra sismi di qualsiasi magnitudo
            if let filterMagnitude = filterMagnitude, seismic.magnitude.doubleValue < filterMagnitude {
                if !filterShowNear {
                    keep = false
                } else {
                    if seismic.userDistance > filterShowNearRadius {
                        keep = false
                    }
                }
            }
            
            
            // filtro sismi forti
            if let filterStrongEarthquake = filterStrongEarthquake, seismic.provider == "EMSC" && filterStrongEarthquakeEnabled && seismic.magnitude.doubleValue > filterStrongEarthquake {
                keep = true
            }
            
            // filtro tempo
            if let filterTime = filterTime, seismic.timeDifference > filterTime {
                keep = false
            }
            
            if keep {
                filtered.append(seismic)
            }
        }
        
        return filtered
    }
}