#!/usr/bin/swift
import Foundation

guard CommandLine.arguments.count >= 2 else {
  fatalError("Usage: ./Day_01 <input.txt>")
}


let ranges: [ClosedRange<Int>] = try! String.init(contentsOfFile: CommandLine.arguments[1],
  encoding: .utf8)
.split(separator: ",")
.map { rangeString in
  guard let separatorIdx = rangeString.firstIndex(of: "-"),
  let lower = Int(rangeString[..<separatorIdx]),
  let upper = Int(rangeString[rangeString.index(after: separatorIdx)...]) else {
    fatalError("L16 : [ERROR] Failed to create ClosedRange!")
  }
  return lower...upper
}

var invalidIdSum: Int = 0

for range in ranges {
  for number in range {
    let numString = String(number)
    let length = numString.count
    guard length.isMultiple(of: 2) else { continue }
    let mid = numString.index(numString.startIndex, offsetBy: length / 2)
    let left  = numString[numString.startIndex..<mid]
    let right = numString[mid..<numString.endIndex]
    if left == right {
      invalidIdSum += number
    }
  }
}
print("=======Part 1=======\n\(invalidIdSum)")

invalidIdSum = 0
func isRepeating(_ x: Int) -> Bool {
  if x < 10 { return false }
  var digits = 0
  var temp = x
  while temp > 0 {
    digits += 1
    temp /= 10
  }
  if digits < 2 { return false }
  for period in 1...(digits / 2) {
    guard digits % period == 0 else { continue }
    var divisor = 1
    for _ in 0..<period { divisor *= 10 }
    let pattern = x % divisor
    guard pattern != 0 else { continue }
    var reconstructed = 0
    var multiplier = 1
    for _ in 0..<(digits / period) {
      reconstructed += pattern * multiplier
      multiplier *= divisor
    }
    if reconstructed == x { return true }
  }
  return false
}

ranges.forEach { range in 
  for id in range {
    if isRepeating(id) {
      invalidIdSum += id
    }
  }
}
print("=======Part 2=======\n\(invalidIdSum)")

invalidIdSum = 0
ranges.forEach { group in
  for id in group {
    let numString = String(id)
    let numstrLength = numString.count
    if numstrLength < 2 { continue }
    for patternLength in 1...(numstrLength / 2) {
      let remainder = numString.replacingOccurrences(of: numString[..<numString.index(numString.startIndex, offsetBy: patternLength)], with: "")
      if remainder.isEmpty {
        invalidIdSum += id
        break
      }
    }
  }
}

print("=======Part 2.2=======\n\(invalidIdSum)")