val invalidEX = List(21211, 21614, 21608, 30006, 30005, 21604, 21601, 14101)
val reachEX = List(21612, 30004)

def sendSms = Action { implicit request =>
    val smsTo = request.body.asFormUrlEncoded.get("number").head
    val deviceId = request.body.asFormUrlEncoded.get("deviceId").head
    try {
      if(smsTo.length<=6||smsTo.length>=18||deviceId.length>=150){
       Ok(write(Map("result" -> "error")))
      }else{
      if (smsNeeded(smsTo)) {
        if (numberBlocked(smsTo)) {
            if (!todayBlocked(smsTo)) {
              var code = random6Digit
              val appLang =request.acceptLanguages(0).code.toString.splitAt(2)._1
              var body = ""
              appLang.equals("en") match {
                case true =>
                  body = Messages("sms_body", "n", code)(Lang(appLang))
                case false =>
                  body = Messages("sms_body", "n", code)(Lang(appLang)) + "n" + Messages("sms_body", "n", code)(Lang("en"))
              }
              TwilioAPI.sendSMS(smsTo, body)
              Future {todayEntry(smsTo) }
              Ok(Json.obj("response" -> "success"))
            } else
              Ok(Json.obj("response" -> "temporaryblock"))
        } else
          Ok(Json.obj("response" -> "permanentblocked"))
      } else {
        Ok(Json.obj("response" -> "regular"))
      }
     }
    } catch {
      case twilioEx: TwilioRestException =>
        if (invalidEX.contains(twilioEx.getErrorCode))
          Ok(Json.obj("response" -> "invalidNumber"))
        else if (reachEX.contains(twilioEx.getErrorCode))
          Ok(Json.obj("response" -> "unreachableNumber"))
        else {
          Future { models.LogFile.errorLogs(Json.obj("route" -> request.tags, "post" -> request.body.asFormUrlEncoded.toString, "address" -> request.remoteAddress, "error" -> twilioEx).toString) }
          Ok(Json.obj("response" -> "error"))
        }
      case e: Exception =>
        println(e)
        Future { models.LogFile.errorLogs(Json.obj("route" -> request.tags, "post" -> request.body.asFormUrlEncoded.toString, "address" -> request.remoteAddress, "error" -> e.toString).toString) }
        Ok(Json.obj("response" -> "error"))
    }
  }

val invalidEX = List(21211, 21614, 21608, 30006, 30005, 21604, 21601, 14101)
val reachEX = List(21612, 30004)


case class SmsPhoneNumber(value: String)

def parseSmsPhoneNumber(valueAsString: String): Option[SmsPhoneNumber] = {
  if(valueAsString.length<=6||valueAsString.length>=18) {
    return Some(SmsPhoneNumber(valueAsString))
  } else {
    return None
  }
}


case class SmsDeviceId(value: String)

def parseSmsDeviceId(valueAsString: String): Option[SmsDeviceId] = {
  if(valueAsString.length<=8||valueAsString.length>=150) {
    return Some(SmsDeviceId(valueAsString))
  } else {
    return None
  }
}

sealed trait SmsPhoneNumberStatus
case class SmsNotNeeded extends SmsPhoneNumberStatus
case class NumberBlocked extends SmsPhoneNumberStatus
case class NumberTemporarilyBlocked extends SmsPhoneNumberStatus
case class Valid extends SmsPhoneNumberStatus

def checkSmsPhoneNumberStatus(smsPhoneNumber:SmsPhoneNumber) :SmsPhoneNumberStatus = {
  if (!smsNeeded(smsPhoneNumber)) {
    return SmsNotNeeded
  } else if (!numberBlocked(smsPhoneNumber)) {
    return NumberBlocked
  } else if (todayBlocked(smsPhoneNumber)) {
    return NumberTemporarilyBlocked
  } else {
    return Valid
  }
}

def buildMessageBody(code:String,appLang:String):String = {
  if (appLang.equals("en"))  {
    return Messages("sms_body", "n", code)(Lang(appLang))
  } else {
    return Messages("sms_body", "n", code)(Lang(appLang)) + "n" + Messages("sms_body", "n", code)(Lang("en"))
  }
}


sealed trait SentSmsResult
case class InvalidNumber extends SentSmsResult
case class UnreachableNumber extends SentSmsResult
case class Error(message:String) extends SentSmsResult
case class Success extends SentSmsResult

def doSendSms(recipient:SmsPhoneNumber,body:String):SentSmsResult = {
  try{
    TwilioAPI.sendSMS(recipient, body)
  } catch {
      case twilioEx: TwilioRestException =>
        if (invalidEX.contains(twilioEx.getErrorCode))
          return InvalidNumber
        else if (reachEX.contains(twilioEx.getErrorCode))
          return UnreachableNumber
        else {
          return Error(twilioEx)
        }
      case e: Exception =>
          return Error(e.toString)
    }
}

def sendSms = Action { implicit request =>
    val smsPhoneNumber = parseSmsPhoneNumber(request.body.asFormUrlEncoded.get("number").head)
    val smsDeviceId = parseSmsDeviceId(deviceId)//not sure where devideId came from

    if(smsPhoneNumber.isEmpty() || smsDeviceId.isEmpty()) {
      Ok(write(Map("result" -> "error")))
    } else {
      checkSmsPhoneNumberStatus(smsPhoneNumber.get) match {
        case SmsNotNeeded => Ok(Json.obj("response" -> "regular"))
        case NumberBlocked => Ok(Json.obj("response" -> "permanentblocked"))
        case NumberTemporarilyBlocked => Ok(Json.obj("response" -> "temporaryblock"))
        case Valid => {
          doSendSms(smsPhoneNumber,buildMessageBody(random6Digit,request.acceptLanguages(0).code.toString.splitAt(2)._1 )) match {
            case InvalidNumber =>  {
               Ok(Json.obj("response" -> "invalidNumber"))
            }
            case UnreachableNumber =>  {
               Ok(Json.obj("response" -> "unreachableNumber"))
            }
            case e:Error =>  {
              Future { models.LogFile.errorLogs(Json.obj("route" -> request.tags, "post" -> request.body.asFormUrlEncoded.toString, "address" -> request.remoteAddress, "error" -> e.message).toString) }
              Ok(Json.obj("response" -> "error"))
            }
            case Success =>  {
              Future {todayEntry(smsTo) }
              Ok(Json.obj("response" -> "success"))
            }
          }
        }
      }
    }
  }