get timestamp start, end boundary for Dayz

.swift

//: Playground - noun: a place where people can play

import Foundation

extension String {
  var hasNumeric: Bool {
    return self.rangeOfCharacter(from: .decimalDigits) != nil
  }
  
  var isNumeric : Bool {
    get {
      return Double(self) != nil
    }
  }
  
  func trimLastIndexIfNeeded(lastCharacterLists: [String]) -> String {
    var mutateSelf = self
    if let last = self.last {
      lastCharacterLists.forEach {
        if String(last) == $0 {
          mutateSelf = String(self.dropLast())
        }
      }
    }
    
    return mutateSelf
  }

  func containsInValidCharacter() -> Bool {
    let characterSet = CharacterSet(charactersIn: "#!~`@$%^&*-+();={}[],.<>?\\\"\'")
    let range = (self as NSString).rangeOfCharacter(from: characterSet)
    return range.location != NSNotFound
  }
}

extension String {
  func contains(find: String) -> Bool{
    return self.range(of: find) != nil
  }
  func containsIgnoringCase(find: String) -> Bool{
    return self.range(of: find, options: .caseInsensitive) != nil
  }
}

// MARK: TypeAliases
typealias StartTimeStampBoundary = Int
typealias EndTimeStampBoundary = Int

var searchTimeStampTuple: (StartTimeStampBoundary?, EndTimeStampBoundary?) = (nil, nil)

func ConvertStringToTimeStamp(inputTimeString: String) -> Int? {
  let dateFormatter = DateFormatter()
  dateFormatter.timeZone = TimeZone.current // TimeZone(abbreviation: "UTC+9")
  dateFormatter.dateFormat = "yyyy/MM/dd HH:mm:ss"
  if let searchDate = dateFormatter.date(from: inputTimeString) {
    let searchUnixTimestamp = Int(searchDate.timeIntervalSince1970)
    return searchUnixTimestamp
  }
  
  return nil
}

func HowManyDaysInMonth(year: Int, month: Int) -> Int {
  let dateComponents = DateComponents(year: year, month: month)
  let calendar = Calendar.current
  let date = calendar.date(from: dateComponents)!
  
  let range = calendar.range(of: .day, in: .month, for: date)!
  let numDays = range.count
  print(numDays) // 31
  return numDays
}

func HowManySecondsHavePassed(from fromDateStr: String, to toDateStr: String) -> Int? {
  let dateFormatter = DateFormatter()
  dateFormatter.dateFormat = "yyyy/MM/dd HH:mm:ss"
  if let searchDate1 = dateFormatter.date(from: fromDateStr) {
    if let searchDate2 = dateFormatter.date(from: toDateStr) {
      let calendar = Calendar.current
      let dateComponents = calendar.dateComponents([.second], from: searchDate1, to: searchDate2)
      
      let seconds = dateComponents.second
      return seconds
    }
  }
  return nil
}

enum TimeSearchType {
  case millennium
  case year
  case month
  case day
  case hour
  case minute
  case second
}

func DayzTimeStampConverter(timeSearchKeyword: String) -> (StartTimeStampBoundary?, EndTimeStampBoundary?) {
  let trimmedTimeSearchKeyword = timeSearchKeyword.trimLastIndexIfNeeded(lastCharacterLists: ["/", ":", " "])
  guard !trimmedTimeSearchKeyword.containsInValidCharacter() else { return (nil, nil) }
  
  var searchType: TimeSearchType?
  
  var searchModeCheckStr = trimmedTimeSearchKeyword
  searchModeCheckStr = searchModeCheckStr
                        .replacingOccurrences(of: "/", with: "")
                        .replacingOccurrences(of: ":", with: "")
                        .replacingOccurrences(of: " ", with: "")
  
  switch searchModeCheckStr.count {
  case 1:
    guard trimmedTimeSearchKeyword.isNumeric else { return (nil, nil) }
    print("millennium year mode!")
    searchType = .millennium
  case 4:
    print("year mode!")
    searchType = .year
  case 6:
    print("month mode!")
    searchType = .month
  case 8:
    print("day mode!")
    searchType = .day
  case 10:
    print("hour mode!")
    searchType = .hour
  case 12:
    print("minute mode!")
    searchType = .minute
  case 14:
    print("seconds mode!")
    searchType = .second
  default:
    print("not categorized!")
    searchTimeStampTuple = (nil, nil)
    return (nil, nil)
  }
  
  guard let completedSearchType = searchType else {
    searchTimeStampTuple = (nil, nil)
    return (nil, nil)
  }
  
  var days: String?
  let startMillenniumYearAsString = trimmedTimeSearchKeyword + "000"  // example:  "2" + "000"
  
  if completedSearchType == .millennium {
    guard let yearAsInt = Int(startMillenniumYearAsString) else {
      searchTimeStampTuple = (nil, nil)
      return (nil, nil)
    }
    
    days = String(HowManyDaysInMonth(year: yearAsInt, month: 12))
  } else if completedSearchType == .year {
    guard let yearAsInt = Int(trimmedTimeSearchKeyword) else {
      searchTimeStampTuple = (nil, nil)
      return (nil, nil)
    }
    
    days = String(HowManyDaysInMonth(year: yearAsInt, month: 12))
  } else {
    guard case let searchTimeStringComponents = trimmedTimeSearchKeyword.components(separatedBy: "/"),
          searchTimeStringComponents.count >= 2 else {
      searchTimeStampTuple = (nil, nil)
      return (nil, nil)
    }
    let yearAsStr = searchTimeStringComponents[0]
    let monthAsStr = searchTimeStringComponents[1]
    
    guard let yearAsInt = Int(yearAsStr), let monthAsInt = Int(monthAsStr) else {
      searchTimeStampTuple = (nil, nil)
      return (nil, nil)
    }
    
    days = String(HowManyDaysInMonth(year: yearAsInt, month: monthAsInt))
  }
  
  guard let dayz = days else {
    searchTimeStampTuple = (nil, nil)
    return (nil, nil)
  }
  
  switch completedSearchType {
  case .millennium:
    if let startMillenniumYearAsInt = Int(startMillenniumYearAsString) {
      let endMillenniumYearAsInt = startMillenniumYearAsInt + 999
      let endMillenniumYearAsString = String(endMillenniumYearAsInt)  // example: "2" + "999"
      
      if let startTimeStamp = ConvertStringToTimeStamp(inputTimeString: startMillenniumYearAsString + "/01" + "/01" + " " + "00:00:00") {
        let startTimeFormat = startMillenniumYearAsString + "/01" + "/01" + " " + "00:00:00"
        let endTimeFormat = endMillenniumYearAsString + "/12" + "/" + dayz + " " + "23:59:59"
        
        if let passedTimeStamp = HowManySecondsHavePassed(from: startTimeFormat,
                                                          to: endTimeFormat) {
          let endTimeStamp = startTimeStamp + passedTimeStamp + 1
          print("endTimeStamp : ", endTimeStamp)
          
          searchTimeStampTuple = (startTimeStamp, endTimeStamp)
          return (startTimeStamp, endTimeStamp)
        } else {
          print("overflow")
          return (nil, nil)
        }
      } else {
        print("??")
        return (nil, nil)
      }
    }
  case .year:
    if let startTimeStamp = ConvertStringToTimeStamp(inputTimeString: trimmedTimeSearchKeyword + "/01" + "/01" + " " + "00:00:00") {
      if let passedTimeStamp = HowManySecondsHavePassed(from: trimmedTimeSearchKeyword + "/01" + "/01" + " " + "00:00:00",
                                                        to: trimmedTimeSearchKeyword + "/12" + "/" + dayz + " " + "23:59:59") {
        let endTimeStamp = startTimeStamp + passedTimeStamp + 1
        print("endTimeStamp : ", endTimeStamp)
        
        searchTimeStampTuple = (startTimeStamp, endTimeStamp)
        return (startTimeStamp, endTimeStamp)
      } else {
        print("!?")
      }
    } else {
      print("??")
    }
  case .month:
    if let startTimeStamp = ConvertStringToTimeStamp(inputTimeString: trimmedTimeSearchKeyword + "/01" + " " + "00:00:00") {
      if let passedTimeStamp = HowManySecondsHavePassed(from: trimmedTimeSearchKeyword + "/01" + " " + "00:00:00",
                                                        to: trimmedTimeSearchKeyword + "/" + dayz + " " + "23:59:59") {
        let endTimeStamp = startTimeStamp + passedTimeStamp + 1
        
        searchTimeStampTuple = (startTimeStamp, endTimeStamp)
        return (startTimeStamp, endTimeStamp)
      }
    }
  case .day:
    if let startTimeStamp = ConvertStringToTimeStamp(inputTimeString: trimmedTimeSearchKeyword + " " + "00:00:00") {
      if let passedTimeStamp = HowManySecondsHavePassed(from: trimmedTimeSearchKeyword + " " + "00:00:00",
                                                        to: trimmedTimeSearchKeyword + " " + "23:59:59") {
        let endTimeStamp = startTimeStamp + passedTimeStamp + 1
        
        searchTimeStampTuple = (startTimeStamp, endTimeStamp)
        return (startTimeStamp, endTimeStamp)
      }
    }
  case .hour:
    if let startTimeStamp = ConvertStringToTimeStamp(inputTimeString: trimmedTimeSearchKeyword + ":00:00") {
      if let passedTimeStamp = HowManySecondsHavePassed(from: trimmedTimeSearchKeyword + ":00:00",
                                                        to: trimmedTimeSearchKeyword + ":59:59") {
        let endTimeStamp = startTimeStamp + passedTimeStamp + 1
        
        searchTimeStampTuple = (startTimeStamp, endTimeStamp)
        return (startTimeStamp, endTimeStamp)
      }
    }
  case .minute:
    if let startTimeStamp = ConvertStringToTimeStamp(inputTimeString: trimmedTimeSearchKeyword + ":00") {
      let endTimeStamp = startTimeStamp + 60
      
      searchTimeStampTuple = (startTimeStamp, endTimeStamp)
      return (startTimeStamp, endTimeStamp)
    }
  case .second:
    print("second mode in!")
    if let startTimeStamp = ConvertStringToTimeStamp(inputTimeString: trimmedTimeSearchKeyword) {
      searchTimeStampTuple = (startTimeStamp, startTimeStamp)
      return (startTimeStamp, startTimeStamp)
    }
    break
  }
  
  searchTimeStampTuple = (0, 0)
  return (0, 0)
}


let str = " ".trimLastIndexIfNeeded(lastCharacterLists: ["/", ":", " "])
str.containsInValidCharacter()


let testStr = "2"
let trimStr = testStr.trimLastIndexIfNeeded(lastCharacterLists: ["/", ":", " "])
trimStr

let timeStampBoundaryTuple = DayzTimeStampConverter(timeSearchKeyword: testStr)

let start = timeStampBoundaryTuple.0
let end = timeStampBoundaryTuple.1

start
end