/**
 * 中介者模式
 * 定義：用一箇中介者物件封裝一系列的物件互動，中介者使各物件不需要顯示地相互作用，從而使耦合鬆散，

而且可以獨立地改變它們之間的互動
 *
 * 抽象中介者：定義好同事類物件到中介者物件的介面，用於各個同事類之間的通訊。一般包括一個或幾個抽象的事件方法，

並由子類去實現。
 * 中介者實現類：從抽象中介者繼承而來，實現抽象中介者中定義的事件方法。從一個同事類接收訊息，然後通過訊息影響其他同時類。
 * 同事類：如果一個物件會影響其他的物件，同時也會被其他物件影響，那麼這兩個物件稱為同事類。在類圖中，同事類只有一個，

這其實是現實的省略，\
 * 
 * 在實際應用中，同事類一般由多個組成，他們之間相互影響，相互依賴。同事類越多，關係越複雜。
 * 並且，同事類也可以表現為繼承了同一個抽象類的一組實現組成。在中介者模式中，同事類之間必須通過中介者才能進行訊息傳遞。
 */

//抽象中介

abstract class AbstractSoftWare(val name: String) {
  private val persons = new ArrayBuffer[Person]()

  def addPerson(person: Person): Unit = {
    if (persons.forall(!person.eq(_))) {
      println(s"群 $name 添加了成員：${person.name}")
      persons += person
    } else {
      println(s"${person.name} 已經在群中了")
    }
  }

  def removePerson(person: Person) {
    if (persons.exists(person.eq(_))) {
      println(s"群 $name 刪除了成員：${person.name}")
      persons -= person
    } else {
      println(s"${person.name} 不在群中了")
    }
  }

  //群發
  def notify(person: Person, message: String): Unit = {
    if (persons.exists(person.eq(_))) {
      persons.filter(!person.eq(_)).foreach(p => println(s"${p.name}從${person.name}接收到資訊:$message"))
    } else {
      println(s"${person.name}您已經不在群組:$name")
    }
  }
  //私聊
  def pm(send: Person, receive: Person, message: String): Unit = send match {
    case s if persons.exists(s.eq(_)) => receive match {
      case r if persons.exists(r.eq(_)) => {
        println(s"${send.name} 傳送訊息 給 ${receive.name} 的訊息為： ${message}")
      }
      case _ => {
        println(s"${receive.name}沒有使用許可權 ")
      }
    }
    case _ => println(s"${send.name}沒有使用許可權 ")
  }
}

//具體中介 qq
class QQSoftware(name: String) extends AbstractSoftWare(name) {
  override def notify(person: Person, message: String): Unit = {
    println(s"這裡是qq群:$name")
    super.notify(person, message)
  }

  override def pm(send: Person, receive: Person, message: String): Unit = {
    println(s"使用qq軟體進行私聊")
    super.pm(send, receive, message)
  }

}

/**
 * msn，具體中介者
 * @param name 群名
 */
class MSNSoftware(name: String) extends AbstractSoftWare(name) {
  override def notify(person: Person, message: String): Unit = {
    println(s"這裡是msn群:$name")
    super.notify(person, message)
  }

  override def pm(send: Person, receive: Person, message: String): Unit = {
    println(s"使用msn軟體進行私聊")
    super.pm(send, receive, message)
  }

}

//抽象同事

abstract class Person(val name: String) {

  def setAbstractSoftware(software: AbstractSoftWare)

  /**
   * 發言
   * @param message 資訊
   */
  def speak(message: String): Unit

  /**
   * 刪除使用者
   * @param person 使用者
   */
  def remove(person: Person): Unit

  /**
   * 增加使用者
   * @param person 使用者
   */
  def add(person: Person): Unit

  /**
   * 私聊
   * @param person 接收者
   * @param message 資訊
   */
  def privateChat(person: Person, message: String): Unit
}

/**
 * 管理員角色，屬於同事
 * @param name 名稱
 */
class Admin(name: String) extends Person(name) {
  private var abstractSoftware: AbstractSoftWare = null

  def setAbstractSoftware(software: AbstractSoftWare) = abstractSoftware = software

  override def speak(message: String) = abstractSoftware.notify(this, message)

  /**
   * 刪除
   * @param person 使用者
   */
  def remove(person: Person) = abstractSoftware.removePerson(person)

  /**
   * 增加
   * @param person 使用者
   */
  def add(person: Person) = {
    println(s"${name}進行新增使用者${person.name}的操作")
    abstractSoftware.addPerson(person)
  }

  /**
   * 私聊
   * @param person 接收者
   * @param message 資訊
   */
  def privateChat(person: Person, message: String) = abstractSoftware.pm(this, person, message)
}

/**
 * 普通使用者角色，屬於同事
 * @param name 名稱
 */
class Member(name: String) extends Person(name) {
  private var abstractSoftware: AbstractSoftWare = null

  def setAbstractSoftware(software: AbstractSoftWare) = abstractSoftware = software

  override def speak(message: String) = abstractSoftware.notify(this, message)

  /**
   * 增加使用者
   * @param person 使用者
   */
  override def add(person: Person): Unit = {
    println(s"${name}您不是管理員，不具備增加使用者許可權")

  }

  /**
   * 判斷是否為刪除自己，如果是刪除自己則為退群
   * @param person 使用者
   */
  override def remove(person: Person): Unit = {
    if (person.eq(this)) {
      println(s"$name，您將退出${abstractSoftware.name}")
      abstractSoftware.removePerson(person)
    } else {
      println(s"${name}您不是管理員，不具備刪除使用者許可權")
    }
  }

  /**
   * 私聊
   * @param person 接收者
   * @param message 資訊
   */
  def privateChat(person: Person, message: String) = abstractSoftware.pm(this, person, message)
}

object mediator extends App {
  val admin: Person = new Admin("admin")
  val member1: Person = new Member("member1")
  val member2: Person = new Member("member2")
  val member3: Person = new Member("member3")
  val member4: Person = new Member("member4")

  val qqSoftware: AbstractSoftWare = new QQSoftware("研發中心")
  admin.setAbstractSoftware(qqSoftware)
  member1.setAbstractSoftware(qqSoftware)
  member2.setAbstractSoftware(qqSoftware)
  member3.setAbstractSoftware(qqSoftware)
  member4.setAbstractSoftware(qqSoftware)

  admin.add(admin)
  admin.add(member1)
  admin.add(member2)
  admin.add(member3)
  admin.add(member4)
  admin.add(member1)

  admin.speak("hello")
  admin.remove(member1)

  member1.speak("hi")

  member2.add(member1)
  member2.remove(member2)

  member2.speak("admin")

  member3.privateChat(admin, "你好")
  member3.privateChat(member2, "你好")

  member2.privateChat(admin, "加我")

  println("------------------------------------------")

  val msnSoftware: AbstractSoftWare = new MSNSoftware("通研事業部")
  admin.setAbstractSoftware(msnSoftware)
  member1.setAbstractSoftware(msnSoftware)
  member2.setAbstractSoftware(msnSoftware)
  member3.setAbstractSoftware(msnSoftware)
  member4.setAbstractSoftware(msnSoftware)

  admin.add(admin)
  admin.add(member1)
  admin.add(member2)
  admin.add(member3)
  admin.add(member4)
  admin.add(member1)

  admin.speak("hello")
  admin.remove(member1)

  member1.speak("hi")

  member2.add(member1)

  member2.speak("admin")

  member2.privateChat(member3, "test")
}