package com.fiddlerwoaroof.experiments.graphql_addressbook

import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
import akka.http.scaladsl.model.StatusCodes._
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.server._
import akka.stream.ActorMaterializer
import sangria.ast.Document
import sangria.execution.{ErrorWithResolver, Executor, QueryAnalysisError}
import sangria.macros.derive._
import sangria.marshalling.sprayJson._
import sangria.parser.QueryParser
import sangria.schema._
import spray.json.{JsObject, JsString, JsValue}

import cats.Monoid
import cats.instances.all._


import scala.util.{Failure, Success}

trait Identifiable {
  def id: String
}

class AddressBook {

  import AddressBook.PNHelper

  private val Contacts = List(
    Contact("1",
      EnglishName("John", Some("Apple"), "Seed"),
      Address("1103 Foo St.", "Ventura", "CA", "93003", "USA"),
      pn"333-444-3333"),
    Contact("1",
      EnglishName("Bob", None, "Marley"),
      Address("1103 Maricopa Ave.", "Ventura", "CA", "93003", "USA"),
      pn"435-2039"),
  )

  def contact(id: String): Option[Contact] =
    Contacts find (_.id == id)

  def addressesByPartialName(name: String, addressType: String = "home"): Seq[Address] =
    Contacts
      .filter(_.name.name.toLowerCase contains name)
      .map(_.address)

  def contacts: List[Contact] = Contacts
}

object AddressBook {

  implicit class PNHelper(private val sc: StringContext) extends AnyVal {
    def pn(args: Any*): PhoneNumber = {
      val str = sc.parts.head
      val parts = str.split('-')
      parts match {
        case Array(cc, ac, pref, suf) => PhoneNumber(cc.toInt, ac.toInt, pref.toInt, suf.toInt)
        case Array(ac, pref, suf) => PhoneNumber(1, ac.toInt, pref.toInt, suf.toInt)
        case Array(pref, suf) => PhoneNumber(1, 805, pref.toInt, suf.toInt)
      }
    }
  }

}

case class Picture(width: Int, height: Int, url: Option[String])

case class PhoneNumber(countryCode: Int, areaCode: Int, prefix: Int, suffix: Int) {
  def formatted = f"(${areaCode}%03d) ${prefix}%03d-${suffix}%04d"
  def localFormatted = f"${prefix}%03d-${suffix}%04d"
  def intlFormatted = f"+$countryCode (${areaCode}%03d) ${prefix}%03d-${suffix}%04d"
}

case class Address(address: String, city: String, state: String, zip: String, country: String)

trait Name {
  def name: String

  def sortName: String
}

case class EnglishName(first: String, middle: Option[String], last: String) extends Name {
  def name: String = s"$first ${middle.map(x => s"$x ").getOrElse("")}$last"

  def sortName: String = s"$last, $first"
}

case class Contact(id: String, name: Name, address: Address, phoneNumber: PhoneNumber) extends Identifiable {
  def picture(size: Int): Picture =
    Picture(
      width = size,
      height = size,
      url = Some(s"//cdn.com/$size/$id.jpg"))
}

object Hello extends App {
  implicit val PictureType: ObjectType[Unit, Picture] =
    deriveObjectType[Unit, Picture](
      ObjectTypeDescription("The product picture"),
      DocumentField("url", "Picture CDN URL"))

  val IdentifiableType: InterfaceType[Unit, Identifiable] =
    InterfaceType(
      "Identifiable",
      "Entity that can be identified",
      fields[Unit, Identifiable](
        Field("id", StringType, resolve = _.value.id)))

  implicit val AddressType: ObjectType[Unit, Address] =
    deriveObjectType[Unit, Address](
      ObjectTypeDescription("A Contact's address"))

  implicit val PhoneNumberType: ObjectType[Unit, PhoneNumber] =
    deriveObjectType[Unit, PhoneNumber](
      IncludeMethods("formatted", "localFormatted", "intlFormatted"))

  val NameType: InterfaceType[Unit, Name] =
    InterfaceType(
      "Name",
      "An interface for things that represent a name",
      fields[Unit, Name](
        Field("name", StringType, resolve = _.value.name),
        Field("sortName", StringType, resolve = _.value.sortName)))

  implicit val EnglishNameType: ObjectType[Unit, EnglishName] =
    deriveObjectType[Unit, EnglishName](
      Interfaces(NameType))

  val ContactType =
    deriveObjectType[Unit, Contact](
      Interfaces(IdentifiableType),
      IncludeMethods("picture"))

  val Id = Argument("id", StringType)

  val QueryType =
    ObjectType("Query", fields[AddressBook, Unit](
      Field("contact", OptionType(ContactType),
        description = Some("Return product with specific `id`."),
        arguments = Id :: Nil,
        resolve = c => c.ctx.contact(c arg Id)),

      Field("contacts", ListType(ContactType),
        description = Some("Returns all products"),
        resolve = _.ctx.contacts)
    ))

  val schema = Schema(QueryType)

  implicit val system = ActorSystem("sangria-server")
  implicit val materializer = ActorMaterializer()

  import system.dispatcher

  val route: Route =
    (post & path("graphql")) {
      entity(as[JsValue]) {
        requestJson => graphQLEndpoint(requestJson)
      }
    } ~
      get {
        getFromResource("graphiql.html")
      }

  def graphQLEndpoint(requestJson: JsValue) = {
    val JsObject(fields) = requestJson
    val JsString(query) = fields("query")

    val operation = fields.get("operationName") collect {
      case JsString(op) => op
    }

    val vars = fields.get("variables") match {
      case Some(obj: JsObject) => obj
      case _ => JsObject.empty
    }

    QueryParser.parse(query) match {
      case Success(queryAst) =>
        complete(executeGraphQLQuery(queryAst, operation, vars))
      case Failure(error) =>
        complete(BadRequest, JsObject("error" -> JsString(error.getMessage)))
    }
  }

  def executeGraphQLQuery(query: Document, op: Option[String], vars: JsObject) =
    Executor.execute(schema, query, new AddressBook,
      variables = vars,
      operationName = op)
      .map(OK -> _)
      .recover {
        case error: QueryAnalysisError => BadRequest -> error.resolveError
        case error: ErrorWithResolver => InternalServerError -> error.resolveError
      }

  Http().bindAndHandle(route, "0.0.0.0", 4930)
}