package controllers

import play.api._
import play.api.mvc._
import play.api.libs.ws.WS
import scala.concurrent.Await
import scala.concurrent.duration.Duration
import models.Usuario
import scala.concurrent._
import play.api.libs.json.JsArray
import play.api.libs.json.JsArray
import play.api.libs.json.JsArray
import models.Previsao
import models.ResultadoPrevisao
import models.GoogleAcesso
import models.GoogleServer
import models.GoogleLocal
import play.api.mvc.Request
import models.GoogleAcesso




object Application extends Controller {

  implicit val context = scala.concurrent.ExecutionContext.Implicits.global
  var usuarioP = new Usuario("", "");
  val formate = new java.text.SimpleDateFormat("dd/MM/yyyy")


  def index = Action { request =>
    val isLocal = request.host == "localhost:9000" || request.host == "127.0.0.1:9000"
    val loginUrl = if(isLocal) GoogleLocal.loginUrl else GoogleServer.loginUrl
    val loginUrl2 : Option[String] = if(isLocal) Some(GoogleServer.loginUrl) else
      None
    Ok(views.html.index(loginUrl, loginUrl2)).discardingCookies("auth_token")

  }

  def googlecallback = Action.async{
  request =>
    val optCode: Option[String] = request.getQueryString("code")
    val isLocal = request.host == "localhost:9000" || request.host == "127.0.0.1:9000"

    val googleCredenciais : GoogleAcesso = if(request.host == "localhost:9000"|| request.host == "127.0.0.1:9000") GoogleLocal else GoogleServer

    optCode match {
      case None => index.apply(request)
      case Some(code) => {
          val params = Map("code" -> Seq(code),
                           "client_id" -> Seq(googleCredenciais.clientID),
                           "client_secret" -> Seq(googleCredenciais.clientSecret),
                           "redirect_uri" -> Seq(googleCredenciais.callbackURL),
                           "grant_type" -> Seq("authorization_code"))

          val tokenRequest = WS.url("https://accounts.google.com/o/oauth2/token").post(params)
          for {
             resposta <- tokenRequest
             respostaDados <- {
                val accessToken = (resposta.json \ "access_token").as[String]
                val url = s"https://www.googleapis.com/oauth2/v2/userinfo?access_token=$accessToken"
                WS.url(url).get
             }
          } yield {
            val respJson = respostaDados.json
            val usuario = new Usuario((respJson \ "picture").as[String], (respJson \ "name").as[String])
            usuarioP = usuario;
            Ok(views.html.pesquisa(usuario, Left("")))
          }
        }
      }
  }

 def pesquise(cidade: String, dia: String) = Action.async { request =>

            val diasMaisUm = dia.toInt + 1
            val city = java.net.URLEncoder.encode(cidade, "UTF-8")
            val url = s"http://api.openweathermap.org/data/2.5/forecast/daily/?q=$city&lang=pt&units=metric&cnt=$diasMaisUm&APPID=926700d7e887255b946acb938a6bdf20"


            WS.url(url).get.map { resposta =>
        val jsonResp = resposta.json
        val cod: Int = (jsonResp \ "cod").as[String].toInt
         cidade  match {
          case t:String if(t.isEmpty()) => { Ok(views.html.pesquisa(usuarioP, Left("Preencha o campo cidade"), Option(cidade, dia))) }
          case t:String if(!t.isEmpty()) => {


          cod match{
                                case x: Int if(x != 200) => { Ok(views.html.pesquisa(usuarioP, Left("Cidade nao encontrada"), Option(cidade, dia))) }
                                case 200 => {

        val cidadeEncontrada: String = (jsonResp \ "city" \ "name").as[String]
        val pais: String = (jsonResp \ "city" \ "country").as[String]
        val lista = (jsonResp \ "list").asInstanceOf[JsArray].value.tail

       val previsoes = for(previsao <- lista)
         yield {
        val weather = (previsao \ "weather").asInstanceOf[JsArray](0)
        val icon = (weather \ "icon").as[String]
        val url_icon = s"http://openweathermap.org/img/w/$icon.png"
         val data = formate.format(new java.util.Date(1000L * (previsao \ "dt").as[Long]))
        val descricao = (weather \ "description").as[String]
        val tempMin= (previsao \ "temp" \ "min").as[Float]
        val tempMax = (previsao \ "temp" \ "max").as[Float]
        val umidade = (previsao \ "humidity").as[Float]

        new Previsao(url_icon, data, descricao, tempMin, tempMax, umidade)
       }

       val resultadoPesquisa = new ResultadoPrevisao(cidadeEncontrada, pais, previsoes.toList)


        Ok(views.html.pesquisa(usuarioP, Right(resultadoPesquisa)))
                                        }
                                }
                }
        }
        }

 }
}