//
//  String.swift
//  PlusBank
//
//  Created by Valentin Titov on 02.02.2021.
//

import UIKit

protocol Stringable {
  var stringValue:  String { get }
}

protocol OptionalStringable {
  var stringValue:  String? { get }
}

//MARK: - Constants
extension String {
  static let empty: String = ""
  static let whitespace: String = " "
  static let slash: String = "/"
  static let newLine: String = "\n"
  static let endLine: String = "\r\n"
  static let colon: String = ":"
  static let semicolon: String = ";"
  static let equal: String = "="
  static let and: String = "&"
}

extension String {
  func substringInRange(_ range: NSRange) -> String {
    let range =
      index(startIndex, offsetBy: range.location)
      ..<
      index(startIndex, offsetBy: range.location + range.length)
    return String(self[range])
  }
  
  func replaceStringInRange(
    _ range: NSRange,
    with string: String
  ) -> String {
    return (self as NSString)
      .replacingCharacters(in: range,  with: string)
      .trimmingCharacters(in: .whitespaces) as String
  }
}

extension String {
  func index(from: Int) -> Index {
    return self.index(startIndex, offsetBy: from)
  }
  
  func substring(from: Int) -> String {
    let fromIndex = index(from: from)
    return String(self[fromIndex...])
  }
  
  func substring(to: Int) -> String {
    let toIndex = index(from: to)
    return String(self[..<toIndex])
  }
  
  func substring(with r: Range<Int>) -> String {
    let startIndex = index(from: r.lowerBound)
    let endIndex = index(from: r.upperBound)
    return String(self[startIndex..<endIndex])
  }
}

extension String {
    subscript (bounds: CountableClosedRange<Int>) -> String {
        let start = index(startIndex, offsetBy: bounds.lowerBound)
        let end = index(startIndex, offsetBy: bounds.upperBound)
        return String(self[start...end])
    }

    subscript (bounds: CountableRange<Int>) -> String {
        let start = index(startIndex, offsetBy: bounds.lowerBound)
        let end = index(startIndex, offsetBy: bounds.upperBound)
        return String(self[start..<end])
    }
}

//MARK: - Letters formatting
extension String {
  var firstCapitalized: String {
    prefix(1).capitalized + dropFirst()
  }
  
  var firstLowercased: String {
    prefix(1).lowercased() + dropFirst()
  }
  
  var positiveStringNumber: String {
    return "+ \(self)"
  }
  
  var negativeStringNumber: String {
    return "- \(self)"
  }
  
  var titleCase: String {
    return self
      .replacingOccurrences(of: "([A-Z])",
                            with: " $1",
                            options: .regularExpression,
                            range: range(of: self))
      .trimmingCharacters(in: .whitespacesAndNewlines)
      .capitalized
    }
}

extension String {
  var normalizePhone: String {
    let decimalPhone = self.decimalString() as String
    let formatted: String
    if let symb = decimalPhone.first, (symb == "7" || symb == "8") {
      formatted = String(decimalPhone.dropFirst())
    } else {
      formatted = decimalPhone
    }
    return formatted
  }
  func decimalString() -> NSString  {
    return components(separatedBy: NSCharacterSet.decimalDigits.inverted).joined() as NSString
  }

}


extension String {
  
  func addHighlight(texts: [String],
                    color: UIColor = .systemBlue) -> NSMutableAttributedString {
    
    let attr = NSMutableAttributedString(string: self, attributes: nil)
    
    for text in texts {
      let range = (attr.string as NSString).range(of: text)
      attr.setAttributes([.foregroundColor: color], range: range)
    }
    
    return attr
  }
  
  func addUnderline() -> NSMutableAttributedString  {
    
    let textRange = NSRange(location: 0, length: self.count)
    let attr = NSMutableAttributedString(string: self)
    attr.addAttribute(.underlineStyle,
                      value: NSUnderlineStyle.single.rawValue,
                      range: textRange)
    
    return attr
  }
  
  func remove(currency: CurrencyType) -> String {
    let value = self
      .replacingOccurrences(of: currency.symbol, with: "")
      .replacingOccurrences(of: " ", with: "")
    return value
  }
  
  func formattingRemoveSpaces() -> String {
    return removeSpaces().findReplace(find: " ", replace: "", all: true)
  }
  
  func currencyInputFormatting() -> String {
    
    func formatting(text: String, digits: Int) -> String {
      let formatting =
      text.currencyInputFullFormatting(digits: digits, spaces: false)
        .remove(currency: .rub)
        .removeSpaces()
      return formatting
    }
    
    let removeSpace = self.formattingRemoveSpaces()
    
    let needle: Character = ","
    if let idx = removeSpace.firstIndex(of: needle) {
      let pos = removeSpace.distance(from: removeSpace.startIndex, to: idx)
      
      
      let result1 = removeSpace.components(separatedBy: ",")
      
      if result1.count > 2 {
        
        let result = String(removeSpace.dropLast())
        return result
        
      } else if result1.count > 1 {
        
        let components = result1[1]
        print("components \(components.count) ")
        
        if components.count != 0 {
          
          var digits = 0
          let digitsMax = 2
          if components.count > digitsMax {
            let newComponents = String(components.prefix(2))
            let text = result1[0] + newComponents
            
            return formatting(text: text, digits: digitsMax)
          }
          else if digitsMax >= components.count {
            digits = components.count
          }
          
          let text = result1[0] + components
          return formatting(text: text, digits: digits)
        } else {
          return removeSpace // formatting(text: removeSpace, digits: 0)
        }
        
        
      }
      
      print("Found \(needle) at position \(pos) -- \(result1.count) ")
      
      return removeSpace // formatting(text: removeSpace, digits: 0)
    }
    else {
      print("Not found")
      return removeSpace
    }
  }
  
  
  func currencyInputFullFormatting(digits: Int, spaces: Bool = true) -> String {
    
    var number: NSNumber!
    let formatter = NumberFormatter()
    formatter.numberStyle = .currencyAccounting
    formatter.currencySymbol = "₽"
    formatter.maximumFractionDigits = digits
    formatter.minimumFractionDigits = digits
    
    var amountWithPrefix = self
    
    // remove from String: "$", ".", ","
    let regex = try! NSRegularExpression(pattern: "[^0-9]", options: .caseInsensitive)
    amountWithPrefix = regex.stringByReplacingMatches(in: amountWithPrefix, options: NSRegularExpression.MatchingOptions(rawValue: 0), range: NSMakeRange(0, self.count), withTemplate: "")
    
    var value: Double = 100
    if digits == 1 {
      value = 10
    } else if digits == 0 {
      value = 1
    }
    
    let double = (amountWithPrefix as NSString).doubleValue
    number = NSNumber(value: (double / value))
    
    // if first number is 0 or all numbers were deleted
    guard number != 0 as NSNumber else {
      return ""
    }
    
    let result = formatter.string(from: number)!
    if !spaces {
      return result.formattingRemoveSpaces()
    }
    return result
  }
}

extension String {
  
  func find(_ find: String) -> Bool {
    range(of: find) != nil
  }
  
  func indexInt(of char: Character, last: Bool = false) -> (index: Index, number: Int)? {
    if last {
      guard let index = lastIndex(of: char) else { return nil }
      return ( index, index.utf16Offset(in: self) )
    } else {
      guard let index = firstIndex(of: char) else { return nil }
      return ( index, index.utf16Offset(in: self) )
    }
  }
  
  func findReplace(find: String, replace: String, all: Bool = false) -> String {
    if all {
      return replacingOccurrences(of: find, with: replace, options: .literal, range: nil)
    } else {
      return replacingOccurrences(of: find, with: replace)
    }
  }
  
  func removeSpaces() -> String  {
    trimmingCharacters(in: .whitespaces)
  }
  
}

extension String {
  func removingEmoji() -> String {
    return String(self.filter { !$0.isEmoji() })
  }
  func removeEmoji() -> String {
    return self.components(separatedBy: CharacterSet.symbols).joined()
  }
}

extension Character {
  fileprivate func isEmoji() -> Bool {
    return
     Character(UnicodeScalar(UInt32(0x1d000))!) <= self && self <= Character(UnicodeScalar(UInt32(0x1f77f))!) ||
     Character(UnicodeScalar(UInt32(0x2100))!) <= self && self <= Character(UnicodeScalar(UInt32(0x26ff))!)  ||
    
    Character(UnicodeScalar(UInt32(0x1f600))!) <= self && self <= Character(UnicodeScalar(UInt32(0x1f64f))!) ||
    Character(UnicodeScalar(UInt32(0x1f300))!) <= self && self <= Character(UnicodeScalar(UInt32(0x1f5ff))!) ||
    Character(UnicodeScalar(UInt32(0x1f680))!) <= self && self <= Character(UnicodeScalar(UInt32(0x1f5ff))!) ||
    Character(UnicodeScalar(UInt32(0x2600))!) <= self && self <= Character(UnicodeScalar(UInt32(0x2600))!) ||
    Character(UnicodeScalar(UInt32(0x2700))!) <= self && self <= Character(UnicodeScalar(UInt32(0x27bf))!) ||
    Character(UnicodeScalar(UInt32(0xfe00))!) <= self && self <= Character(UnicodeScalar(UInt32(0xfe0f))!)
  }
}

// MARK: - Name Of Class

extension NSObject {
  class var nameClss: String{
    return NSStringFromClass(self).components(separatedBy: ".").last!
  }
  var nameClss: String{
    return NSStringFromClass(type(of: self)).components(separatedBy: ".").last!
  }
  var nameObj: String{
    return String(describing: type(of: Self.self))
  }
  func fontSize(se: Bool = false) -> UIFont {
      return UIFont.systemFont(ofSize: se && Device.SE ? 16 : 18)  
  }
}