foo.scala

import scalaz._
import Scalaz._

trait Read[F] { self =>
  def read(f: String): F
}

object Read {
  @inline def apply[F](implicit F: Read[F]): Read[F] = F
}

object Cards {

  sealed trait Suit
  case object Hearts extends Suit
  case object Spades extends Suit
  case object Diamonds extends Suit
  case object Clubs extends Suit

  val Suits = Seq[Suit](Hearts, Spades, Diamonds, Clubs)

  implicit val suitInstance: Read[Suit] with Show[Suit] = new Read[Suit] with Show[Suit] {
    def read(s: String): Suit = s match {
      case "Hearts" => Hearts
      case "Spades" => Spades
      case "Diamonds" => Diamonds
      case "Clubs" => Clubs
      case _ => throw new IllegalArgumentException(s"unknown suit $s")
    }
  }

  sealed trait Value
  case object Two extends Value
  case object Three extends Value
  case object Four extends Value
  case object Five extends Value
  case object Six extends Value
  case object Seven extends Value
  case object Eight extends Value
  case object Nine extends Value
  case object Ten extends Value
  case object Jack extends Value
  case object Queen extends Value
  case object King extends Value
  case object Ace extends Value

  val OrderedValues = IndexedSeq[Value](Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace)

  implicit val valueInstance: Enum[Value]
    with Order[Value]
    with Show[Value]
    with Read[Value] = new Enum[Value] with Show[Value] with Read[Value] {

    def read(v: String): Value = Two

    def succ(v: Value): Value = {
     if (OrderedValues.last == v) {
        v
      } else {
        OrderedValues.drop(OrderedValues.indexOf(v) + 1).head
      }
    }


    def pred(v: Value): Value =  {
      if (OrderedValues.head == v) {
        v
      } else {
        OrderedValues.take(OrderedValues.indexOf(v)).last
      }
    }

    def order(x: Value, y: Value): Ordering = {
      val indexOfx = OrderedValues.indexOf(x)
      val indexOfy = OrderedValues.indexOf(y)

      if (indexOfx < indexOfy) {
        Ordering.LT
      } else if (indexOfx == indexOfy) {
        Ordering.EQ
      } else {
        Ordering.GT
      }
    }

    override def min = Some(Two)
    override def max = Some(Ace)
  }

  type Card = (Suit, Value)

  type Deck = List[Card]

  object Values {
  }

  object Deck {
    def apply(): Deck = {
      (Suits.toList |@| OrderedValues.toList) { (_, _) }
    }

    def filterSuit(s: Suit): Deck = {
      Deck().filter(_._1 == s)
    }

//    def shuffle(d: Deck): Deck = {
//      d.shuffl
//    }
  }

  def run() {
    println(Enum[Value].pred(Two))
    println(Enum[Value].pred(Ace))
    println(Enum[Value].succ(Ace))
    println(Enum[Value].succ(Two))
    println(Enum[Value].max)
    println(Enum[Value].min)
    println(Enum[Value].fromToL(Two, Ace))
    println(Read[Suit].read("Hearts"))
    println(Deck())
    println(Deck.filterSuit(Hearts))
  }
}