//Protocol Syntax
protocol SomeProtocol {
  
}
class SomeClass: SuperClass, FirstProtocol, SecondProtocol {
  
}

protocol SomeProtocol {
  var mustBeSettable: Int { get set }
  var doesNotNeedToBeSettable: Int { get }
}
protocol AnotherProtocol {
  static var someTypeProperty: Int { get set }
}

protocol FullyNamed {
  var fullName: String { get }
}
struct Person: FullyNamed {
  var fullName: String
}
let john = Person.init(fullName: "Jhon Appleseed")

protocol RandomNumberGenerator {
  func random() -> Double
}
class LinearCongruentialGenerator: RandomNumberGenerator {
  var lastRandom = 42.0
  let m = 139968.0
  let a = 3877.0
  let c = 29573.0
  func random() -> Double {
      lastRandom = (lastRandom * a + c).truncatingRemainder(dividingBy: m)
      return lastRandom / m
  }
}
let generator = LinearCongruentialGenerator.init()
print("Here's a random number: \(generator.random())")

//Mutating Method Requirements
protocol Togglable {
  mutating func toggle()
}
enum OnOffSwitch: Togglable {
  case off, on
  mutating func toggle() {
      switch self {
      case .off:
          self = .on
      case .on:
          self = .off
      }
  }
}
var lightSwitch = OnOffSwitch.off
lightSwitch.toggle()

protocol SomeSimpleInitializerProtocol {
  init()
}
class SomeSuperClass {
  init() {
      
  }
}
class SomeSubClass: SomeSuperClass, SomeSimpleInitializerProtocol {
  //"required" from SomeProtocol conformance; "override" from SomeSuperClass
  required override init() {
      
  }
}

//Protocols as Types
class Dice {
  let sides: Int
  let generator: RandomNumberGenerator
  init(sides: Int, generator: RandomNumberGenerator) {
      self.sides = sides
      self.generator = generator
  }
  func roll() -> Int {
      return Int(generator.random() * Double(sides)) + 1
  }
}
//六面骰子，生成法则使用线性同余生成器
var d6 = Dice.init(sides: 6, generator: LinearCongruentialGenerator())
for _ in 1...5 {
  print("Random dice roll is \(d6.roll())")
}

//Delegation
//协议DiceGame可以被用于所有使用骰子的游戏
protocol DiceGame {
  var dice: Dice { get }
  func play()
}
//协议DiceGameDelegate可以被用于所有使用跟踪骰子过程的类型
protocol DiceGameDelegate {
  //提供关于DiceGame的三个代理方法，使用该DiceGameDelegate的实例可以直接调用其三个方法，而不需要关心其内部实现。创建遵循该代理的类具体实现其方法
  //类似于OC中，遵守某协议（:delegate）的类实现该方法。而定义某协议的地方调用该方法
  func gameDidStart(_ game: DiceGame)
  func game(_game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int)
  func gameDidEnd(_ game: DiceGame)
}

//使用骰子的游戏蛇与梯子
class SnakesAndLadders: DiceGame{
  //25个格
  let finalSquare = 25
  //实现DiceGame协议，指定使用6面线性同余生成随机数的骰子
  let dice = Dice.init(sides: 6, generator: LinearCongruentialGenerator.init())
  //初始为0
  var square = 0
  //定义格子数组
  var board = [Int]()
  //初始化不同格子向上或是向下移动
  init() {
      board = Array(repeating: 0, count: finalSquare + 1)
      board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
      board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
  }
  //定义DiceGameDelegate类型代理
  //此代理非必须，定义为可选类型
  var delegate: DiceGameDelegate?
  //实现DiceGame协议，实现play方法
  func play() {
      square = 0
      //使用可选控制链避免代理为空时调用方法
      delegate?.gameDidStart(self)
      gameLoop: while square != finalSquare {
          let diceRoll = dice.roll()
          delegate?.game(_game: self, didStartNewTurnWithDiceRoll: diceRoll)
          switch square + diceRoll {
          case finalSquare:
              break gameLoop
          case let newSquare where newSquare > finalSquare:
              continue gameLoop
          default:
              square += diceRoll
              square += board[square]
          }
      }
      delegate?.gameDidEnd(self)
  }
}

class DiceGameTracker: DiceGameDelegate {
  var numberOfTurns = 0
  func gameDidStart(_ game: DiceGame) {
      numberOfTurns = 0
      if game is SnakesAndLadders {
          print("Started a new game of Snakes and Ladders")
      }
      print("The game is using a \(game.dice.sides)-sides dice")
  }
  func game(_game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) {
      numberOfTurns += 1
      print("Rolled a \(diceRoll)")
  }
  func gameDidEnd(_ game: DiceGame) {
      print("The game lasted for \(numberOfTurns) turns")
  }
}

//初始化实现DiceGameDelegate的类型实例
let tracker = DiceGameTracker.init()
//初始化游戏
let game = SnakesAndLadders.init()
//将游戏代理DiceGameDelegate类型指定为实现该代理的类型实例
game.delegate = tracker
//执行游戏的开始方法
game.play()

//Adding Protocol Conformance with an Extension
protocol TextRepresentable {
  var textualDescription: String { get }
}
extension Dice: TextRepresentable {
  var textualDescription: String {
      return "A \(sides)-sides dice"
   }
}

//Declaring Protocol Adoption with an Extension
struct Hamster {
  var name: String
  var textualDescription: String {
      return "A hamster named \(name)"
  }
}
extension Hamster: TextRepresentable {}
let simonTheHamster = Hamster(name: "Simon")
let somethingTextRepresentable: TextRepresentable = simonTheHamster
//print(somethingTextRepresentable.textualDescription)
print(simonTheHamster.textualDescription)

let things: [TextRepresentable] = [game, d12, simonTheHamster]
for thing in things {
  //注意这里的thing是TextRepresentable协议类型，可以访问thing.textualDescription，但是不能访问其他的
  print(thing.textualDescription)
}

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
  // protocol definition goes here
}