/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.openwhisk.core.cli.test

import java.io.File
import java.io.BufferedWriter
import java.io.FileWriter
import org.junit.runner.RunWith
import org.scalatest.junit.JUnitRunner

import org.apache.commons.io.FileUtils

import common.WhiskProperties
import common.TestHelpers
import common.TestUtils._
import common.Wsk
import common.WskProps
import common.WskTestHelpers
import java.nio.charset.StandardCharsets

@RunWith(classOf[JUnitRunner])
class WskConfigTests extends TestHelpers with WskTestHelpers {

  implicit val wskprops = WskProps()
  val wsk = new Wsk

  behavior of "Wsk CLI config"

  it should "fail to show api build when setting apihost to bogus value" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    try {
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      wsk.cli(Seq("property", "set", "-i", "--apihost", "xxxx.yyyy"), env = env)
      val rr = wsk.cli(Seq("property", "get", "--apibuild", "-i"), env = env, expectedExitCode = NETWORK_ERROR_EXIT)
      rr.stdout should include regex ("""whisk API build\s*Unknown""")
      rr.stderr should include regex ("Unable to obtain API build information")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "use default cli configuration when an empty string WSK_CONFIG_FILE is supplied" in {
    val env = Map("WSK_CONFIG_FILE" -> "")
    val stderr = wsk.cli(Seq("property", "get", "-i"), env = env, expectedExitCode = ERROR_EXIT).stderr
    stderr should include("The API host is not valid: An API host must be provided.")
  }

  it should "validate default property values" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
    val stdout = wsk
      .cli(Seq("property", "unset", "--auth", "--cert", "--key", "--apihost", "--apiversion", "--namespace"), env = env)
      .stdout
    try {
      stdout should include regex ("ok: whisk auth unset")
      stdout should include regex ("ok: client cert unset")
      stdout should include regex ("ok: client key unset")
      stdout should include regex ("ok: whisk API host unset")
      stdout should include regex ("ok: whisk API version unset")
      stdout should include regex ("ok: whisk namespace unset")

      wsk
        .cli(Seq("property", "get", "--auth"), env = env)
        .stdout should include regex ("""(?i)whisk auth\s*$""") // default = empty string
      wsk
        .cli(Seq("property", "get", "--cert"), env = env)
        .stdout should include regex ("""(?i)client cert\s*$""") // default = empty string
      wsk
        .cli(Seq("property", "get", "--key"), env = env)
        .stdout should include regex ("""(?i)client key\s*$""") // default = empty string
      wsk
        .cli(Seq("property", "get", "--apihost"), env = env)
        .stdout should include regex ("""(?i)whisk API host\s*$""") // default = empty string
      wsk
        .cli(Seq("property", "get", "--namespace"), env = env)
        .stdout should include regex ("""(?i)whisk namespace\s*_$""") // default = _
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "reject authenticated command when no auth key is given" in {
    // override wsk props file in case it exists
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
    val stderr = wsk.cli(Seq("list") ++ wskprops.overrides, env = env, expectedExitCode = MISUSE_EXIT).stderr
    try {
      stderr should include regex (s"usage[:.]")
      stderr should include("--auth is required")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "reject a command when the API host is not set" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    try {
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stderr = wsk.cli(Seq("property", "get", "-i"), env = env, expectedExitCode = ERROR_EXIT).stderr
      stderr should include("The API host is not valid: An API host must be provided.")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "show api build details" in {
    val tmpProps = File.createTempFile("wskprops", ".tmp")
    try {
      val env = Map("WSK_CONFIG_FILE" -> tmpProps.getAbsolutePath())
      wsk.cli(Seq("property", "set", "-i") ++ wskprops.overrides, env = env)
      val rr = wsk.cli(Seq("property", "get", "--apibuild", "--apibuildno", "-i"), env = env)
      rr.stderr should not include ("https:///api/v1: http: no Host in request URL")
      rr.stdout should not include regex("Cannot determine API build")
      rr.stdout should include regex ("""(?i)whisk API build\s+20.*""")
      rr.stdout should include regex ("""(?i)whisk API build number\s+.*""")
    } finally {
      tmpProps.delete()
    }
  }

  it should "get apihost removing any trailing white spaces and line comments" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    try {
      val writer = new BufferedWriter(new FileWriter(tmpwskprops))
      writer.write(s"APIHOST=http://localhost:10001    # This is a comment!   ")
      writer.close()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stdout = wsk.cli(Seq("property", "get", "-i", "--apihost"), env = env).stdout
      stdout should include regex ("whisk API host\\s+http://localhost:10001$")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "set apihost, auth, and namespace" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    try {
      val namespace = wsk.namespace.whois()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stdout = wsk
        .cli(
          Seq(
            "property",
            "set",
            "-i",
            "--apihost",
            wskprops.apihost,
            "--auth",
            wskprops.authKey,
            "--namespace",
            namespace),
          env = env)
        .stdout
      stdout should include(s"ok: whisk auth set")
      stdout should include(s"ok: whisk API host set to ${wskprops.apihost}")
      stdout should include(s"ok: whisk namespace set to ${namespace}")
    } finally {
      tmpwskprops.delete()
    }
  }

  // If client certificate verification is off, should ingore run below tests.
  if (!WhiskProperties.getProperty("whisk.ssl.client.verification").equals("off")) {
    it should "set valid cert key to get expected success result for client certificate verification" in {
      val tmpwskprops = File.createTempFile("wskprops", ".tmp")
      try {
        val namespace = wsk.namespace.list().stdout.trim.split("\n").last
        val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
        // Send request to https://<apihost>/api/v1/namespaces, wsk client passes client certificate to nginx, nginx will
        // verify it by client ca's openwhisk-client-ca-cert.pem
        val stdout = wsk
          .cli(
            Seq(
              "property",
              "set",
              "-i",
              "--apihost",
              wskprops.apihost,
              "--auth",
              wskprops.authKey,
              "--cert",
              wskprops.cert,
              "--key",
              wskprops.key,
              "--namespace",
              namespace),
            env = env)
          .stdout
        stdout should include(s"ok: client cert set")
        stdout should include(s"ok: client key set")
        stdout should include(s"ok: whisk auth set")
        stdout should include(s"ok: whisk API host set to ${wskprops.apihost}")
        stdout should include(s"ok: whisk namespace set to ${namespace}")
      } finally {
        tmpwskprops.delete()
      }
    }

    it should "set invalid cert key to get expected exception result for client certificate verification" in {
      val tmpwskprops = File.createTempFile("wskprops", ".tmp")
      try {
        val namespace = wsk.namespace.list().stdout.trim.split("\n").last
        val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
        val thrown = the[Exception] thrownBy wsk.cli(
          Seq(
            "property",
            "set",
            "-i",
            "--apihost",
            wskprops.apihost,
            "--auth",
            wskprops.authKey,
            "--cert",
            "invalid-cert.pem",
            "--key",
            "invalid-key.pem",
            "--namespace",
            namespace),
          env = env)
        thrown.getMessage should include("cannot validate certificate")
      } finally {
        tmpwskprops.delete()
      }
    }
  }

  it should "ensure default namespace is used when a blank namespace is set" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    try {
      val writer = new BufferedWriter(new FileWriter(tmpwskprops))
      writer.write(s"NAMESPACE=")
      writer.close()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stdout = wsk.cli(Seq("property", "get", "-i", "--namespace"), env = env).stdout
      stdout should include regex ("whisk namespace\\s+_")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "show api build version using property file" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    try {
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      wsk.cli(Seq("property", "set", "-i") ++ wskprops.overrides, env = env)
      val stdout = wsk.cli(Seq("property", "get", "--apibuild", "-i"), env = env).stdout
      stdout should include regex ("""(?i)whisk API build\s+20.*""")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "show api build using explicit protocol for apihost" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    try {
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val controllerProtocol = WhiskProperties.getProperty("controller.protocol")
      val apihost =
        s"${controllerProtocol}://${WhiskProperties.getBaseControllerHost()}"
      wsk.cli(Seq("property", "set", "--apihost", apihost), env = env)
      val rr = wsk.cli(Seq("property", "get", "--apibuild", "-i"), env = env)
      rr.stdout should not include regex("""whisk API build\s*Unknown""")
      rr.stderr should not include regex("Unable to obtain API build information")
      rr.stdout should include regex ("""(?i)whisk API build\s+201.*""")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "return configure the missing Cert file" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val keyFile = File.createTempFile("key", ".pem")
    try {
      val writer = new BufferedWriter(new FileWriter(tmpwskprops))
      writer.write(s"KEY=${keyFile.getAbsolutePath()}\n")
      writer.close()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stderr = wsk
        .cli(
          Seq("property", "get", "--apibuild", "--apihost", wskprops.apihost, "--apiversion", wskprops.apiversion),
          env = env,
          expectedExitCode = ERROR_EXIT)
        .stderr
      stderr should include regex ("""The Cert file is not configured. Please configure the missing Cert file.""")
    } finally {
      tmpwskprops.delete()
      keyFile.delete()
    }
  }

  it should "return configure the missing Key file" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val certFile = File.createTempFile("cert", ".pem")
    try {
      val writer = new BufferedWriter(new FileWriter(tmpwskprops))
      writer.write(s"CERT=${certFile.getAbsolutePath()}\n")
      writer.close()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stderr = wsk
        .cli(
          Seq("property", "get", "--apibuild", "--apihost", wskprops.apihost, "--apiversion", wskprops.apiversion),
          env = env,
          expectedExitCode = ERROR_EXIT)
        .stderr
      stderr should include regex ("""The Key file is not configured. Please configure the missing Key file.""")
    } finally {
      tmpwskprops.delete()
      certFile.delete()
    }
  }

  it should "return unable to load the X509 key pair with both Cert and Key files missing" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val certFile = File.createTempFile("cert", ".pem")
    val keyFile = File.createTempFile("key", ".pem")
    try {
      val writer = new BufferedWriter(new FileWriter(tmpwskprops))
      writer.write(s"CERT=${certFile.getAbsolutePath()}\n")
      writer.write(s"KEY=${keyFile.getAbsolutePath()}\n")
      writer.close()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stderr = wsk
        .cli(
          Seq("property", "get", "--apibuild", "--apihost", wskprops.apihost, "--apiversion", wskprops.apiversion),
          env = env,
          expectedExitCode = ERROR_EXIT)
        .stderr
      stderr should include regex ("""Unable to load the X509 key pair due to the following reason""")
    } finally {
      tmpwskprops.delete()
      certFile.delete()
      keyFile.delete()
    }
  }

  it should "set api host with or without http prefix" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    try {
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      Seq("", "http://", "https://").foreach { prefix =>
        Seq("10", "10:123", "aaa", "aaa:123").foreach { host =>
          val apihost = s"$prefix$host"
          withClue(apihost) {
            val rr = wsk.cli(Seq("property", "set", "--apihost", apihost), env = env)
            rr.stdout.trim shouldBe s"ok: whisk API host set to $apihost"
            rr.stderr shouldBe 'empty
            val fileContent = FileUtils.readFileToString(tmpwskprops, StandardCharsets.UTF_8)
            fileContent should include(s"APIHOST=$apihost")
          }
        }
      }
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "set auth in property file" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
    wsk.cli(Seq("property", "set", "--auth", "testKey"), env = env)
    try {
      val fileContent = FileUtils.readFileToString(tmpwskprops, StandardCharsets.UTF_8)
      fileContent should include("AUTH=testKey")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "set multiple property values with single command" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
    val stdout = wsk
      .cli(
        Seq(
          "property",
          "set",
          "--auth",
          "testKey",
          "--cert",
          wskprops.cert,
          "--key",
          wskprops.key,
          "--apihost",
          "openwhisk.ng.bluemix.net",
          "--apiversion",
          "v1"),
        env = env)
      .stdout
    try {
      stdout should include regex ("ok: whisk auth set")
      stdout should include regex ("ok: client cert set")
      stdout should include regex ("ok: client key set")
      stdout should include regex ("ok: whisk API host set")
      stdout should include regex ("ok: whisk API version set")
      val fileContent = FileUtils.readFileToString(tmpwskprops, StandardCharsets.UTF_8)
      fileContent should include("AUTH=testKey")
      fileContent should include("APIHOST=openwhisk.ng.bluemix.net")
      fileContent should include("APIVERSION=v1")
    } finally {
      tmpwskprops.delete()
    }
  }

  it should "create a trigger using property file" in withAssetCleaner(wskprops) { (wp, assetHelper) =>
    val name = "listTriggers"
    val tmpProps = File.createTempFile("wskprops", ".tmp")
    val env = Map("WSK_CONFIG_FILE" -> tmpProps.getAbsolutePath())
    wsk.cli(Seq("property", "set", "--auth", wp.authKey) ++ wskprops.overrides, env = env)
    assetHelper.withCleaner(wsk.trigger, name) { (trigger, _) =>
      wsk.cli(Seq("-i", "trigger", "create", name), env = env)
    }
    tmpProps.delete()
  }

  it should "return configure the missing Cert file for action" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val keyFile = File.createTempFile("key", ".pem")
    try {
      val writer = new BufferedWriter(new FileWriter(tmpwskprops))
      writer.write(s"KEY=${keyFile.getAbsolutePath()}\n")
      writer.close()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stderr = wsk
        .cli(
          Seq("action", "list", "--apihost", wskprops.apihost, "--apiversion", wskprops.apiversion),
          env = env,
          expectedExitCode = ERROR_EXIT)
        .stderr
      stderr should include regex ("""The Cert file is not configured. Please configure the missing Cert file.""")
    } finally {
      tmpwskprops.delete()
      keyFile.delete()
    }
  }

  it should "return configure the missing Key file for action" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val certFile = File.createTempFile("cert", ".pem")
    try {
      val writer = new BufferedWriter(new FileWriter(tmpwskprops))
      writer.write(s"CERT=${certFile.getAbsolutePath()}\n")
      writer.close()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stderr = wsk
        .cli(
          Seq("action", "list", "--apihost", wskprops.apihost, "--apiversion", wskprops.apiversion),
          env = env,
          expectedExitCode = ERROR_EXIT)
        .stderr
      stderr should include regex ("""The Key file is not configured. Please configure the missing Key file.""")
    } finally {
      tmpwskprops.delete()
      certFile.delete()
    }
  }

  it should "return unable to load the X509 key pair with both Cert and Key files missing for action" in {
    val tmpwskprops = File.createTempFile("wskprops", ".tmp")
    val certFile = File.createTempFile("cert", ".pem")
    val keyFile = File.createTempFile("key", ".pem")
    try {
      val writer = new BufferedWriter(new FileWriter(tmpwskprops))
      writer.write(s"CERT=${certFile.getAbsolutePath()}\n")
      writer.write(s"KEY=${keyFile.getAbsolutePath()}\n")
      writer.close()
      val env = Map("WSK_CONFIG_FILE" -> tmpwskprops.getAbsolutePath())
      val stderr = wsk
        .cli(
          Seq("action", "list", "--apihost", wskprops.apihost, "--apiversion", wskprops.apiversion),
          env = env,
          expectedExitCode = ERROR_EXIT)
        .stderr
      stderr should include regex ("""Unable to load the X509 key pair due to the following reason""")
    } finally {
      tmpwskprops.delete()
      certFile.delete()
      keyFile.delete()
    }
  }
}