sats-price/Sources/SatsPrice/SatsViewModel.swift

// This is free software: you can redistribute and/or modify it
// under the terms of the GNU General Public License 3.0
// as published by the Free Software Foundation https://fsf.org
//
//
//  SatsViewModel.swift
//  SatsPrice
//
//  Created by Terry Yiu on 2/19/24.
//

import Foundation
import SwiftUI

class SatsViewModel: ObservableObject {
    @Published var lastUpdated: Date?

    @Published var satsStringInternal: String = ""
    @Published var btcStringInternal: String = ""
    @Published var selectedCurrency: Locale.Currency = Locale.current.currency ?? Locale.Currency("USD")
    @Published var currencyValueStrings: [Locale.Currency: String] = [:]

    var currencyPrices: [Locale.Currency: Decimal] = [:]

    let currentCurrency: Locale.Currency = Locale.current.currency ?? Locale.Currency("USD")

    var currencies: [Locale.Currency] {
        let commonISOCurrencyCodes = Set(Locale.commonISOCurrencyCodes)
        let currentCurrency = Locale.current.currency ?? Locale.Currency("USD")
        if commonISOCurrencyCodes.contains(currentCurrency.identifier) {
            return Locale.commonISOCurrencyCodes.map { Locale.Currency($0) }
        } else {
            var commonAndCurrentCurrencies = Locale.commonISOCurrencyCodes
            commonAndCurrentCurrencies.append(currentCurrency.identifier)
            commonAndCurrentCurrencies.sort()
            return commonAndCurrentCurrencies.map { Locale.Currency($0) }
        }
    }

    var satsString: String {
        get {
            satsStringInternal
        }
        set {
            guard satsStringInternal != newValue else {
                return
            }

            satsStringInternal = newValue

            if let sats {
#if !SKIP
                let btc = sats / Decimal(100000000)
#else
                let btc = sats.divide(Decimal(100000000), 20, java.math.RoundingMode.DOWN)
#endif
                btcStringInternal = btc.formatString()

                updateCurrencyValueStrings()
            } else {
                btcStringInternal = ""
                clearCurrencyValueStrings()
            }
        }
    }

    var btcString: String {
        get {
            btcStringInternal
        }
        set {
            guard btcStringInternal != newValue else {
                return
            }

            btcStringInternal = newValue

            if let btc {
                let sats = btc * Decimal(100000000)
                satsStringInternal = sats.formatString()

                updateCurrencyValueStrings()
            } else {
                satsStringInternal = ""
                clearCurrencyValueStrings()
            }
        }
    }

    func updateCurrencyValueStrings(excludedCurrency: Locale.Currency? = nil) {
        if let btc {
            let currencies = Set([currentCurrency] + currencyValueStrings.keys)
                .filter { $0 != excludedCurrency }

            for currency in currencies {
                if let btcToCurrency = btcToCurrency(for: currency) {
                    currencyValueStrings[currency] = (btc * btcToCurrency).formatString()
                } else {
                    currencyValueStrings[currency] = ""
                }
            }
        } else {
            clearCurrencyValueStrings()
        }
    }

    func clearCurrencyValueStrings() {
        for currency in currencyValueStrings.keys {
            currencyValueStrings[currency] = ""
        }
    }

    func currencyValueString(for currency: Locale.Currency) -> Binding<String> {
        Binding<String>(
            get: {
                self.currencyValueStrings[currency, default: ""]
            },
            set: { newValue in
                guard self.currencyValueStrings[currency] != newValue else {
                    return
                }

                self.currencyValueStrings[currency] = newValue

                if let currencyValue = self.currencyValue(for: currency) {
                    if let btcToCurrency = self.currencyPrices[currency] {
    #if !SKIP
                        let btc = currencyValue / btcToCurrency
    #else
                        let btc = currencyValue.divide(btcToCurrency, 20, java.math.RoundingMode.DOWN)
    #endif
                        self.btcStringInternal = btc.formatString()

                        let sats = btc * Decimal(100000000)
                        self.satsStringInternal = sats.formatString()

                        self.updateCurrencyValueStrings(excludedCurrency: currency)
                    } else {
                        self.satsStringInternal = ""
                        self.btcStringInternal = ""
                        self.clearCurrencyValueStrings()
                    }
                } else {
                    self.satsStringInternal = ""
                    self.btcStringInternal = ""
                    self.clearCurrencyValueStrings()
                }
            }
        )
    }

    func currencyValue(for currency: Locale.Currency) -> Decimal? {
        guard let currencyValueString = currencyValueStrings[currency] else {
            return nil
        }

#if !SKIP
        return Decimal(string: currencyValueString)
#else
        do {
            return Decimal(currencyValueString)
        } catch {
            return nil
        }
#endif
    }

    func btcToCurrency(for currency: Locale.Currency) -> Decimal? {
        currencyPrices[currency]
    }

    func btcToCurrencyString(for currency: Locale.Currency) -> Binding<String> {
        Binding<String>(
            get: {
                self.currencyPrices[currency]?.formatString() ?? ""
            },
            set: { newValue in
#if !SKIP
                if let newPrice = Decimal(string: newValue), self.currencyPrices[currency] != newPrice {
                    self.currencyPrices[currency] = Decimal(string: newValue)

                    if let btc = self.btc {
                        self.currencyValueStrings[currency] = (btc * newPrice).formatString()
                    } else {
                        self.currencyValueStrings[currency] = ""
                    }
                }
#else
                do {
                    if let newPrice = Decimal(newValue), self.currencyPrices[currency] != newPrice {
                        self.currencyPrices[currency] = Decimal(newValue)

                        if let btc = self.btc {
                            self.currencyValueStrings[currency] = (btc * newPrice).formatString()
                        } else {
                            self.currencyValueStrings[currency] = ""
                        }
                    }
                } catch {
                    self.currencyPrices.removeValue(forKey: currency)
                }
#endif
            }
        )
    }

    var sats: Decimal? {
#if !SKIP
        return Decimal(string: satsStringInternal)
#else
        do {
            return Decimal(satsStringInternal)
        } catch {
            return nil
        }
#endif
    }

    var btc: Decimal? {
#if !SKIP
        return Decimal(string: btcStringInternal)
#else
        do {
            return Decimal(btcStringInternal)
        } catch {
            return nil
        }
#endif
    }

    var exceedsMaximum: Bool {
        if let btc, btc > Decimal(21000000) {
            return true
        }
        return false
    }
}

extension Decimal {
    func formatString() -> String {
#if !SKIP
        return String(describing: self)
#else
        return stripTrailingZeros().toPlainString()
#endif
    }
}