import SwiftUI

struct TestNextTextFieldFocus: View {
  @State var inputsValues: [String] = (0..<30).map { i in
    "test \(i) TextField axis is \(i % 2 == 0 ? ".vertical" : ".horizontal")"
  }

  @FocusState var focusedInput: Int?

  var body: some View {
    ScrollViewReader { proxy in
      ScrollView {
        LazyVStack {
          ForEach(0..<inputsValues.count, id: \.self) { i in
            TextField("Value", text: $inputsValues[i], axis: i % 2 == 0 ? .vertical : .horizontal)
              .focused($focusedInput, equals: i)
              .submitLabel(.return)
              .id(i)
              .onSubmit {
                print("submit \(i)")
                // update state here !!
                if (i + 1) < inputsValues.count {
                  focusedInput = i + 1
                } else {
                  focusedInput = nil
                }
              }
          }
        }
        .onChange(of: focusedInput) {
          print("onChange focusedInput:\(String(describing: focusedInput))")
          // react on state change here !!
          proxy.scrollTo($0, anchor: .top)
        }
      }
      .toolbar {
        ToolbarItemGroup(placement: .keyboard) {
          Spacer()
          Button {
            focusedInput = nil
          } label: {
            Text("Done")
          }
        }
      }
    }
  }
}

struct TestNextTextFieldFocus_Previews: PreviewProvider {
  static var previews: some View {
    TestNextTextFieldFocus()
  }
}

import Foundation
import SwiftyJSON

struct NewModel {
    let id: Int
    let name: String
    let notifications: Bool
    let pets: [String]

    init(json: JSON) {
        id = json["id"].intValue
        name = json["name"].stringValue
        notifications = json["notifications"].boolValue
        pets = json["pets"].arrayValue.map { $0.stringValue }
    }
}

print(emptyDoubles[0])

let emptyRange = 0..<0
ClosedRange(emptyRange)

let digitWords = ["one", "two", "three", "four", "five"]
let wordToValue = Dictionary(uniqueKeysWithValues: zip(digitWords, 1 ... 5))
let wordToValueAndRemoveDuplicateKeys = Dictionary(zip(["one", "one", "three", "four", "five"], 1 ... 5)) { max($0, $1) }

var dic: [String: Any] = ["name": "li", "age": 18]
dic as! [String: String]

let x = Int.min
let y = -x
// Overflow error

let z = -Int8.min
// Overflow error

var y = Int8.min
y.negate()
// Overflow error

let z = UInt32(-500)
// Error

let optionalInt: Int? = nil
optionalInt.unsafelyUnwrapped
optionalInt!

let message = s as! String
print("Successful cast to String: \(message)")
// Prints "Successful cast to String: This is a bridged string."
let badCase = v as! String
// Runtime error

Range(0 ... Int.max)

let streets = ["Adams", "Bryant", "Channing", "Douglas", "Evarts"]
let streetsSlice = streets[2...]
print(streetsSlice)
// ["Channing", "Douglas", "Evarts"]

print(streetsSlice.startIndex)
// 2
print(streetsSlice[2])
// "Channing"
print(streetsSlice[0])
// error: Index out of bounds

var array = Array(0 ..< 5)
array.removeFirst(6)
array.removeLast(6)

var s: Set<AnyHashable> = [1, 2, "3"]
s as! Set<Int>

// * a pointer to a null-terminated sequence of UTF-8 code units:
let emoji: StaticString = "\u{1F600}"
emoji.hasPointerRepresentation // -> true
emoji.isASCII // -> false
// emoji.unicodeScalar // -> Fatal error!
emoji.utf8CodeUnitCount // -> 4
emoji.utf8Start[0] // -> 0xF0
emoji.utf8Start[1] // -> 0x9F
emoji.utf8Start[2] // -> 0x98
emoji.utf8Start[3] // -> 0x80
emoji.utf8Start[4] // -> 0x00

// * a single Unicode scalar value, under very limited circumstances:
struct MyStaticScalar: ExpressibleByUnicodeScalarLiteral {
    typealias UnicodeScalarLiteralType = StaticString
    let value: StaticString
    init(unicodeScalarLiteral value: StaticString) {
        self.value = value
    }
}

let emoji: StaticString = MyStaticScalar("\u{1F600}").value
emoji.hasPointerRepresentation // -> false
emoji.isASCII // -> false
emoji.unicodeScalar.value // -> 0x1F600
emoji.utf8CodeUnitCount // -> Fatal error!
emoji.utf8Start // -> Fatal error!

public class TreeNode<T> {
  
  public var value: T
  public var children: [TreeNode] = []
  
  public init(_ value: T) {
    self.value = value
  }
  
  public func add(_ child: TreeNode) {
    children.append(child)
  }
}

extension TreeNode {
  public func forEachDepthFirst(visit: (TreeNode) -> Void) {
    visit(self)
    children.forEach {
      $0.forEachDepthFirst(visit: visit)
    }
  }
}

extension TreeNode {
  public func forEachLevelOrder(visit: (TreeNode) -> Void) {
    visit(self)
    var queue = Queue<TreeNode>()
    children.forEach { queue.enqueue($0) }
    while let node = queue.dequeue() {
      visit(node)
      node.children.forEach { queue.enqueue($0) }
    }
  }
}

extension TreeNode where T: Equatable {
  public func search(_ value: T) -> TreeNode? {
    var result: TreeNode?
    forEachDepthFirst { node in
      if node.value == value {
        result = node
      }
    }
    return result
  }
}

func printEachLevel<T>(for tree: TreeNode<T>) {
    var queue = Queue<TreeNode<T>>()

    /// 加入每层的节点计数，当打印完时，换行
    var nodesLeftInCurrentLevel = 0

    queue.enqueue(tree)
    while !queue.isEmpty {
        nodesLeftInCurrentLevel = queue.count
        while nodesLeftInCurrentLevel > 0 {
            guard let node = queue.dequeue() else { break }
            print("\(node.value) ", terminator: "")
            node.children.forEach { queue.enqueue($0) }
            nodesLeftInCurrentLevel -= 1
        }
        print()
    }
}

// swift-tools-version:4.0
import PackageDescription

let package = Package(
    name: "EmojiJournalServer",
    dependencies: [
      .package(url: "https://github.com/IBM-Swift/Kitura.git", .upToNextMinor(from: "2.5.0")),
      .package(url: "https://github.com/IBM-Swift/HeliumLogger.git", from: "1.7.1"),
      .package(url: "https://github.com/IBM-Swift/CloudEnvironment.git", from: "9.0.0"),
      .package(url: "https://github.com/RuntimeTools/SwiftMetrics.git", from: "2.0.0"),
      .package(url: "https://github.com/IBM-Swift/Health.git", from: "1.0.0"),
    ],
    targets: [
      .target(name: "EmojiJournalServer", dependencies: [ .target(name: "Application"), "Kitura" , "HeliumLogger"]),
      .target(name: "Application", dependencies: [ "Kitura", "CloudEnvironment","SwiftMetrics","Health",      ]),

      .testTarget(name: "ApplicationTests" , dependencies: [.target(name: "Application"), "Kitura","HeliumLogger" ])
    ]
)

import Foundation
import Kitura
import LoggerAPI
import Configuration
import CloudEnvironment
import KituraContracts
import Health

public let projectPath = ConfigurationManager.BasePath.project.path
public let health = Health()

public class App {
  let router = Router()
  let cloudEnv = CloudEnv()
  
  public init() throws {
    // Run the metrics initializer
    initializeMetrics(router: router)
  }
  
  func postInit() throws {
    // Endpoints
    initializeHealthRoutes(app: self)
    router.get("/", handler: helloWorldHandler)
  }
  
  func helloWorldHandler(request: RouterRequest, response: RouterResponse, next: ()->()) {
    response.send("Hello, World!")
    next()
  }
  
  public func run() throws {
    try postInit()
    Kitura.addHTTPServer(onPort: cloudEnv.port, with: router)
    Kitura.run()
  }
}

import Foundation

// 1 Cadabe 是一个组合的协议：Decodable & Encodable

public struct Song: Codable {
  var title: String
  var length: Int
  
  enum CodingKeys: String, CodingKey {
    case title = "songTitle"
    case length = "songLength"
  }
}

public struct Animal: Codable {
  var name: String
  var age: Int?
  var isFriendly: Bool
  var birthday: Date
  var songs: [Song]
}

// 2 嵌套
let baloo = Animal(name: "Baloo",
                   age: 5,
                   isFriendly: true,
                   birthday: Date(),
                   songs: [Song(title: "The Bare Necessities", length: 180)])
let bagheera = Animal(name: "Bagheera",
                      age: nil,
                      isFriendly: true,
                      birthday: Date(),
                      songs: [Song(title: "Jungle's No Place For A Boy", length: 95)])

// 3 处理日期格式，驼峰式与蛇式转换
let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToSnakeCase
encoder.dateEncodingStrategy = .iso8601
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
decoder.dateDecodingStrategy = .iso8601

do {
  // 4
  let encodedBaloo = try encoder.encode(baloo)
  if let balooString = String(data: encodedBaloo, encoding: .utf8) {
    print(balooString)
  }
  let encodedBagheera = try encoder.encode(bagheera)
  if let bagheeraString = String(data: encodedBagheera, encoding: .utf8) {
    print(bagheeraString)
  }
  // 5
  let decodedBaloo = try decoder.decode(Animal.self, from: encodedBaloo)
  print(decodedBaloo)
  let decodedBagheera = try decoder.decode(Animal.self, from: encodedBagheera)
  print(decodedBagheera)
} catch let error {
  print("Error occurred: \(error.localizedDescription)")
}

import Foundation

struct JournalEntry: Codable {
  var id: String?
  var emoji: String
  var date: Date
}

import Foundation
import LoggerAPI
import Kitura

var entries: [JournalEntry] = []

func initializeEntryRoutes(app: App) {
  app.router.get("/entries", handler: getAllEntries)
  app.router.post("/entries", handler: addEntry)
  app.router.delete("/entries", handler: deleteEntry)
  Log.info("Journal entry routes created")
}

func addEntry(entry: JournalEntry, completion: @escaping (JournalEntry?, RequestError?) -> Void) {
  var storedEntry = entry
  storedEntry.id = entries.count.value
  entries.append(storedEntry)
  completion(storedEntry, nil)
}

func getAllEntries(completion: @escaping ([JournalEntry]?, RequestError?) -> Void) -> Void {
  completion(entries, nil)
}

func deleteEntry(id: String, completion: @escaping (RequestError?) -> Void) {
  guard let index = entries.index(where: { $0.id == id }) else {
    return completion(.notFound)
  }
  entries.remove(at: index)
  completion(nil)
}

.package(url: "https://github.com/IBM-Swift/Kitura-OpenAPI.git", from: "1.1.1"),

public class Node<Value> {
  
  public var value: Value
  public var next: Node?
  
  public init(value: Value, next: Node? = nil) {
    self.value = value
    self.next = next
  }
}

public struct LinkedList<Value> {
  
  public var head: Node<Value>?
  public var tail: Node<Value>?
  
  public init() {}
  
  public var isEmpty: Bool {
    return head == nil
  }
  
  // MARK: - 增加和删除节点的方法
  
  // 时间复杂度：O(1)
  public mutating func push(_ value: Value) {
    copyNodes()
    head = Node(value: value, next: head)
    if tail == nil {
      tail = head
    }
  }

  // 时间复杂度：O(1)
  public mutating func append(_ value: Value) {
    copyNodes()
    guard !isEmpty else {
      push(value)
      return
    }
    tail!.next = Node(value: value)
    tail = tail!.next
  }

  // 时间复杂度：O(i) , i 就是给定的index
  public func node(at index: Int) -> Node<Value>? {
    var currentNode = head
    var currentIndex = 0
    while currentNode != nil && currentIndex < index {
      currentNode = currentNode!.next
      currentIndex += 1
    }
    return currentNode
  }
  
  // 时间复杂度：O(1)
  @discardableResult
  public mutating func insert(_ value: Value, after node: Node<Value>) -> Node<Value> {
    copyNodes()
    guard tail !== node else {
      append(value)
      return tail!
    }
    node.next = Node(value: value, next: node.next)
    return node.next!
  }

  // 时间复杂度：O(1)  
  @discardableResult
  public mutating func pop() -> Value? {
    copyNodes()
    defer {
      head = head?.next
      if isEmpty {
        tail = nil
      }
    }
    return head?.value
  }
  
  // 时间复杂度：O(n)
  @discardableResult
  public mutating func removeLast() -> Value? {
    copyNodes()
    guard let head = head else {
      return nil
    }
    guard head.next != nil else {
      return pop()
    }
    var prev = head
    var current = head
    while let next = current.next {
      prev = current
      current = next
    }
    prev.next = nil
    tail = prev
    return current.value
  }

  // 时间复杂度：O(1)  
  @discardableResult
  public mutating func remove(after node: Node<Value>) -> Value? {
    copyNodes()
    defer {
      if node.next === tail {
        tail = node
      }
      node.next = node.next?.next
    }
    return node.next?.value
  }

  // MARK: - 实现值类型和写入时复制
  //使用COW实现价值语义的策略非常简单。在改变链接列表的内容之前，您希望执行底层存储的副本并将所有引用（头部和尾部）更新为新副本。
  private mutating func copyNodes() {
    guard !isKnownUniquelyReferenced(&head) else {
      return
    }
    guard var oldNode = head else {
      return
    }
    
    head = Node(value: oldNode.value)
    var newNode = head
    
    while let nextOldNode = oldNode.next {
      newNode!.next = Node(value: nextOldNode.value)
      newNode = newNode!.next
      oldNode = nextOldNode
    }
    
    tail = newNode
  }
}

// MARK: - 实现Swift的Collection协议

//Swift Collection还允许通过下标进行访问，这是一个很好的术语，用于表示索引可以映射到集合中的值。
extension LinkedList: Collection {
  
  public struct Index: Comparable {
    
    public var node: Node<Value>?
    
    static public func ==(lhs: Index, rhs: Index) -> Bool {
      switch (lhs.node, rhs.node) {
      case let (left?, right?):
        return left.next === right.next
      case (nil, nil):
        return true
      default:
        return false
      }
    }
    
    static public func <(lhs: Index, rhs: Index) -> Bool {
      guard lhs != rhs else {
        return false
      }
      let nodes = sequence(first: lhs.node) { $0?.next }
      return nodes.contains { $0 === rhs.node }
    }
  }
  
  public var startIndex: Index {
    return Index(node: head)
  }
  
  public var endIndex: Index {
    return Index(node: tail?.next)
  }
  
  public func index(after i: Index) -> Index {
    return Index(node: i.node?.next)
  }
  
  public subscript(position: Index) -> Value {
    return position.node!.value
  }
}

func printInReverse<T>(_ list: LinkedList<T>) {
  //巧妙的递归：先迭代后打印，这样打印的就是逆序了
  printInReverse(list.head)
}

private func printInReverse<T>(_ node: Node<T>?) {
  guard let node = node else { return }
  printInReverse(node.next)
  print(node.value)
}

func getMiddle<T>(_ list: LinkedList<T>) -> Node<T>? {
  	//两个步长差一倍，这样快的遍历到终点，慢的刚好到中间
    var fast = list.head
    var slow = list.head

    while let nextFast = fast?.next {
        fast = nextFast.next
        slow = slow?.next
    }

    return slow
}

extension LinkedList {
    // 不断的分割链表，从头部开始，下一步时把之前分割的节点拼接在新的节点之后。
    // 如此遍历到底，就实现了逆序。
    // 核心思路：把每个节点的前节点变成后节点，同时通过遍历时分割成2~3个分段。
    mutating func reverse() {
        tail = head

        var current = head?.next
        //  临时存储逆序的链表
        var prev = head
        prev?.next = nil

        while current != nil {
            let next = current?.next
            current?.next = prev
            prev = current
            current = next
        }

        head = prev
    }
}

func mergeSorted<T: Comparable>(_ left: LinkedList<T>,
                                _ right: LinkedList<T>) -> LinkedList<T> {
    guard !left.isEmpty else {
        return right
    }

    guard !right.isEmpty else {
        return left
    }

    // 定义新的链表的首尾
    var newHead: Node<T>?
    var tail: Node<T>?

    // 原有链表的游标，后面以此遍历
    var currentLeft = left.head
    var currentRight = right.head

    // 初始设置
    if let leftNode = currentLeft, let rightNode = currentRight {
        if leftNode.value < rightNode.value {
            newHead = leftNode
            currentLeft = leftNode.next
        } else {
            newHead = rightNode
            currentRight = rightNode.next
        }
        tail = newHead
    }

    // 遍历
    while let leftNode = currentLeft, let rightNode = currentRight {
        if leftNode.value < rightNode.value {
            tail?.next = leftNode
            currentLeft = leftNode.next
        } else {
            tail?.next = rightNode
            currentRight = rightNode.next
        }
        tail = tail?.next
    }

    if let leftNode = currentLeft {
        tail?.next = leftNode
    }

    if let rightNode = currentRight {
        tail?.next = rightNode
    }

    // 处理新的链表的首尾
    var list = LinkedList<T>()

    list.head = newHead
    // 找到真的尾部节点
    list.tail = {
        while let next = tail?.next {
            tail = next
        }
        return tail
    }()

    return list
}

extension LinkedList where Value: Equatable {
    mutating func removeAll(_ value: Value) {
        // 头部的值相等时单独处理
        while let head = self.head, head.value == value {
            self.head = head.next
        }

        var current = head?.next
        var prev = head

        // 遍历
        while let currentNode = current {
            guard currentNode.value != value else {
                prev?.next = currentNode.next
                current = prev?.next
                continue
            }

            prev = current
            current = current?.next
        }

        tail = prev
    }
}

//泛型Element为存储的元素
public struct Stack<Element> {

  //内部为数组存储所有元素
  private var storage: [Element] = []

  public init() { }

  public init(_ elements: [Element]) {
    storage = elements
  }

  public mutating func push(_ element: Element) {
    storage.append(element)
  }

  @discardableResult
  public mutating func pop() -> Element? {
    return storage.popLast()
  }

  public func peek() -> Element? {
    return storage.last
  }

  public var isEmpty: Bool {
    return peek() == nil
  }
}

extension Stack: CustomStringConvertible {
  public var description: String {
    let topDivider = "----top----\n"
    let bottomDivider = "\n-----------"

    let stackElements = storage
      .map { "\($0)" }
      .reversed()
      .joined(separator: "\n")
    return topDivider + stackElements + bottomDivider
  }
}

extension Stack: ExpressibleByArrayLiteral {
  public init(arrayLiteral elements: Element...) {
    storage = elements
  }
}

let list: LinkedList<Int> = {
  var list = LinkedList<Int>()
  list.push(3)
  list.push(2)
  list.push(1)
  return list
}()

func printInReverse<T>(_ list: LinkedList<T>) {
  var current = list.head
  var stack = Stack<T>()
  
  while let node = current {
    stack.push(node.value)
    current = node.next
  }
  
  while let value = stack.pop() {
    print(value)
  }
}

printInReverse(list)

var testString1 = "h((e))llo(world)()"
var testString2 = "(hello world"

func checkParentheses(_ string: String) -> Bool {
  var stack = Stack<Character>()
  
  for character in string {
    if character == "(" {
      stack.push(character)
    } else if character == ")" {
      if stack.isEmpty {
        return false
      } else {
        stack.pop()
      }
    }
  }
  return stack.isEmpty
}

checkParentheses(testString1)
checkParentheses(testString2)

public protocol Queue {
  
  associatedtype Element
  ///在队列后面插入一个元素。如果操作成功，则返回true。
  mutating func enqueue(_ element: Element) -> Bool
  ///删除队列前面的元素并将其返回。
  mutating func dequeue() -> Element?
  var isEmpty: Bool { get }
  var peek: Element? { get }
}

public struct QueueArray<T>: Queue {
  
  private var array: [T] = []
  public init() {}

  public var isEmpty: Bool {
    return array.isEmpty
  }
  
  public var peek: T? {
    return array.first
  }
  
  public mutating func enqueue(_ element: T) -> Bool {
    array.append(element)
    return true
  }
  
  public mutating func dequeue() -> T? {
    return isEmpty ? nil : array.removeFirst()
  }
}

extension QueueArray: CustomStringConvertible {
  
  public var description: String {
    return String(describing: array)
  }
}

var queue = QueueArray<String>()
queue.enqueue("Ray")
queue.enqueue("Brian")
queue.enqueue("Eric")
queue
queue.dequeue()
queue
queue.peek

public class QueueLinkedList<T>: Queue {
  
  private var list = DoublyLinkedList<T>()
  public init() {}

  public func enqueue(_ element: T) -> Bool {
    list.append(element)
    return true
  }
  
  public func dequeue() -> T? {
    guard !list.isEmpty, let element = list.first else {
      return nil
    }
    return list.remove(element)
  }
  
  public var peek: T? {
    return list.first?.value
  }
  
  public var isEmpty: Bool {
    return list.isEmpty
  }
}

extension QueueLinkedList: CustomStringConvertible {
  
  public var description: String {
    return String(describing: list)
  }
}

var queue = QueueLinkedList<String>()
queue.enqueue("Ray")
queue.enqueue("Brian")
queue.enqueue("Eric")
queue
queue.dequeue()
queue
queue.peek

// MARK: - DoublyLinkedList

public class Node<T> {
  
  public var value: T
  public var next: Node<T>?
  public var previous: Node<T>?
  
  public init(value: T) {
    self.value = value
  }
}

extension Node: CustomStringConvertible {
  
  public var description: String {
    return String(describing: value)
  }
}

public class DoublyLinkedList<T> {
  
  private var head: Node<T>?
  private var tail: Node<T>?
  
  public init() { }
  
  public var isEmpty: Bool {
    return head == nil
  }
  
  public var first: Node<T>? {
    return head
  }
  
  public func append(_ value: T) {
    let newNode = Node(value: value)
    
    guard let tailNode = tail else {
      head = newNode
      tail = newNode
      return
    }
    
    newNode.previous = tailNode
    tailNode.next = newNode
    tail = newNode
  }
  
  public func remove(_ node: Node<T>) -> T {
    let prev = node.previous
    let next = node.next
    
    if let prev = prev {
      prev.next = next
    } else {
      head = next
    }
    
    next?.previous = prev
    
    if next == nil {
      tail = prev
    }
    
    node.previous = nil
    node.next = nil
    
    return node.value
  }
}

extension DoublyLinkedList: CustomStringConvertible {
  
  public var description: String {
    var string = ""
    var current = head
    while let node = current {
      string.append("\(node.value) -> ")
      current = node.next
    }
    return string + "end"
  }
}

public class LinkedListIterator<T>: IteratorProtocol {
  
  private var current: Node<T>?
  
  init(node: Node<T>?) {
    current = node
  }
  
  public func next() -> Node<T>? {
    defer { current = current?.next }
    return current
  }
}

extension DoublyLinkedList: Sequence {
  
  public func makeIterator() -> LinkedListIterator<T> {
    return LinkedListIterator(node: head)
  }
}