//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.stubs

import uk.gov.hmrc.domain.Nino
import com.github.tomakehurst.wiremock.client.WireMock._
import uk.gov.hmrc.agentinvitations.UriPathEncoding.encodePathSegment

trait DesStubs[A] {
  me: A with WiremockAware =>

  def clientId: Nino

  def hasABusinessPartnerRecord(postcode: String = "AA11AA", countryCode: String = "GB"): A = {
    stubFor(get(urlEqualTo(s"/registration/business-details/nino/${encodePathSegment(clientId.value)}"))
      .withHeader("authorization", equalTo("Bearer secret"))
      .withHeader("environment", equalTo("test"))
      .willReturn(aResponse()
        .withStatus(200)
        .withBody(s"""
                     |{
                     |  "businessAddressDetails": {
                     |    "postalCode": "$postcode",
                     |    "countryCode": "$countryCode"
                     |  }
                     |}
              """.stripMargin)))
    this
  }

  def hasNoBusinessPartnerRecord: A = {
    stubFor(get(urlEqualTo(s"/registration/business-details/nino/${encodePathSegment(clientId.value)}"))
      .withHeader("authorization", equalTo("Bearer secret"))
      .withHeader("environment", equalTo("test"))
      .willReturn(aResponse()
        .withStatus(404)))

    this
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.scenarios

import org.scalatest._
import org.scalatest.concurrent.Eventually
import uk.gov.hmrc.agentinvitations.support._
import uk.gov.hmrc.domain.{AgentCode, Nino}


class AgencyFiltersByClientIdAndStatusPlatformISpec extends FeatureSpec with ScenarioHelpers with GivenWhenThen with Matchers with MongoAppAndStubs with Inspectors with Inside with Eventually {

  implicit val arn = RandomArn()
  private implicit val agentCode = AgentCode("LMNOP123456")
  val nino: Nino = nextNino
  val nino2: Nino = nextNino

  feature("Agencies can filter")  {

    scenario("on the client id and status of invitations") {
      val agency = new AgencyRequests(this, arn, port)
      val client = new ClientRequests(this, nino, port)
      Given("An agent is logged in")
      given().agentAdmin(arn, agentCode).isLoggedInWithSessionId().andIsSubscribedToAgentServices()
      given().client(clientId = nino).isLoggedInWithSessionId().hasABusinessPartnerRecord().aRelationshipIsCreatedWith(arn)
      given().client(clientId = nino2).hasABusinessPartnerRecord()

      When("An agent sends invitations to Client 1")
      agencySendsSeveralInvitations(agency)(
        (nino, MtdItService),
        (nino, MtdItService)
      )

      And("Sends an invitations to Client 2")
      agency sendInvitation(nino2, MtdItService)

      And("Client 1 accepts the first invitation")
      clientAcceptsFirstInvitation(client)

      Then("The agent filters by Client 1 and Pending")
      agencyFiltersByClient1Pending(agency)

      Then("The agent filters by Client 2 and Accepted")
      agencyFiltersByClient2Accepted(agency)
    }
  }

  def agencyFiltersByClient1Pending(agency: AgencyRequests) = {
    val invitations = agency.sentInvitations(filteredBy = Seq("clientId" -> nino.value, "status" -> "Pending"))

    invitations.numberOfInvitations shouldBe 1
  }

  def agencyFiltersByClient2Accepted(agency: AgencyRequests) = {
    val invitations = agency.sentInvitations(filteredBy = Seq("clientId" -> nino2.value, "status" -> "Accepted"))

    invitations.numberOfInvitations shouldBe 0
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.scenarios

import org.scalatest._
import org.scalatest.concurrent.Eventually
import uk.gov.hmrc.agentinvitations.support._
import uk.gov.hmrc.domain.{AgentCode, Nino}


class AgencyFilteringByClientIdIPlatformISpec extends FeatureSpec with ScenarioHelpers with GivenWhenThen with Matchers with MongoAppAndStubs with Inspectors with Inside with Eventually {

  override val arn = RandomArn()
  override val nino: Nino = nextNino

  private implicit val agentCode = AgentCode("LMNOP123456")
  private val nino2: Nino = nextNino

  feature("Agencies can filter")  {

    scenario("on the status of clients invitations") {
      val agency = new AgencyRequests(this, arn, port)
      val client1 = new ClientRequests(this, nino, port)
      val client2 = new ClientRequests(this, nino2, port)

      Given("An agent is logged in")
      given().agentAdmin(arn, agentCode).isLoggedInWithSessionId().andIsSubscribedToAgentServices()
      given().client(clientId = nino).hasABusinessPartnerRecord()
      given().client(clientId = nino2).hasABusinessPartnerRecord()

      And("the Agency has sent 1 invitation to 2 different clients")
      agencySendsSeveralInvitations(agency)(
        (nino, MtdItService),
        (nino2, MtdItService)
      )

      When(s"the Agency filters by client ID")
      Then(s"only the client matching that id is returned")
      agencyFiltersById(agency, client1.clientId)
      agencyFiltersById(agency, client2.clientId)
    }
  }

  private def agencyFiltersById(agency: AgencyRequests, clientId: Nino): Unit = {
    val invitation = agency.sentInvitations(filteredBy = Seq("clientId" -> clientId.value))
    invitation.numberOfInvitations shouldBe 1
    invitation.firstInvitation.status shouldBe "Pending"
    invitation.firstInvitation.arn shouldBe agency.arn
    invitation.firstInvitation.clientId shouldBe clientId
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.scenarios

import org.scalatest._
import org.scalatest.concurrent.Eventually
import uk.gov.hmrc.agentinvitations.support.{AgencyRequests, MongoAppAndStubs, RandomArn, ScenarioHelpers}
import uk.gov.hmrc.domain.{AgentCode, Nino}


class AgencyFiltersByClientIdTypePlatformISpec extends FeatureSpec with ScenarioHelpers with GivenWhenThen with Matchers with MongoAppAndStubs with Inspectors with Inside with Eventually {

  implicit val arn = RandomArn()
  private implicit val agentCode = AgentCode("LMNOP123456")
  val nino: Nino = nextNino

  feature("Agencies can filter")  {

    scenario("on the clientIdType of invitations") {
      val agency = new AgencyRequests(this, arn, port)
      Given("An agent is logged in")
      given().agentAdmin(arn, agentCode).isLoggedInWithSessionId().andIsSubscribedToAgentServices()
      given().client(clientId = nino).hasABusinessPartnerRecord()

      When("An agent sends several invitations")
      agencySendsSeveralInvitations(agency)(
        (nino, MtdItService),
        (nino, MtdItService)
      )

      Then("The agent filters by clientIdType=ni")
      agencyFiltersByNi(agency)

      Then("The agent filters by clientIdType=mtd-it-id")
      agencyFiltersByMtdItId(agency)
    }
  }

  def agencyFiltersByNi(agency: AgencyRequests) = {
    val invitations = agency.sentInvitations(filteredBy = Seq("clientIdType" -> "ni"))

    invitations.numberOfInvitations shouldBe 2
  }

  def agencyFiltersByMtdItId(agency: AgencyRequests) = {
    val invitations = agency.sentInvitations(filteredBy = Seq("clientIdType" -> "mtd-it-id"))

    invitations.numberOfInvitations shouldBe 0
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.scenarios

import org.scalatest.{Inside, Inspectors}
import org.scalatest.concurrent.Eventually
import uk.gov.hmrc.agentinvitations.support._
import uk.gov.hmrc.domain.{AgentCode, Nino}
import uk.gov.hmrc.play.test.UnitSpec

class NoInvitationsPlatformISpec extends UnitSpec with MongoAppAndStubs with Inspectors with Inside with Eventually with Requests {

  private implicit val arn = RandomArn()
  private implicit val agentCode = AgentCode("LMNOP123456")
  private val nino: Nino = nextNino

  "Before the Agency has sent any invitations" in {
    val agency = new AgencyRequests(this, arn, port)
    val client = new ClientRequests(this, nino, port)

    given().agentAdmin(arn, agentCode).isLoggedInWithSessionId().andIsSubscribedToAgentServices()
    given().client(clientId = nino).isLoggedInWithSessionId()

    info("the Agency sent invitations should be empty")
    val agencyResponse = agency.sentInvitations()
    agencyResponse.numberOfInvitations shouldBe 0
    agencyResponse.links.invitations shouldBe 'empty
    agencyResponse.links.selfLink shouldBe s"/agent-invitations/agencies/${arn.value}/invitations/sent"
    agencyResponse.embedded.isEmpty shouldBe true

    info("the Clients received invitations should be empty")
    val clientResponse = client.getInvitations()
    clientResponse.numberOfInvitations shouldBe 0
    clientResponse.links.invitations shouldBe 'empty
    clientResponse.links.selfLink shouldBe s"/agent-invitations/clients/ni/${nino.value}/invitations/received"
    clientResponse.embedded.isEmpty shouldBe true
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.support

import play.mvc.Http.HeaderNames.LOCATION
import uk.gov.hmrc.agentinvitations.support.EmbeddedSection.EmbeddedInvitation
import uk.gov.hmrc.agentinvitations.support.HalTestHelpers.HalResourceHelper
import uk.gov.hmrc.agentmtdidentifiers.model.Arn
import uk.gov.hmrc.domain.Nino
import uk.gov.hmrc.play.http.{HeaderCarrier, HttpResponse}
import uk.gov.hmrc.play.http.logging.SessionId

class AgencyRequests(requests: Requests, val arn: Arn, implicit val port: Int) {

  implicit val hc: HeaderCarrier = HeaderCarrier(sessionId = Some(SessionId(arn.value)))

  def sendInvitation(clientId: Nino, service: String = "HMRC-MTD-IT", clientIdType: String = "ni", clientPostcode: String = "AA1 1AA"): String = {

    val response = requests.agencySendInvitation(arn, requests.AgencyInvitationRequest(service, clientIdType, clientId.value, clientPostcode))
    require(response.status == 201, s"Creating an invitation should return 201, was [${response.status}]")
    response.header(LOCATION).get
  }

  def sentInvitations(filteredBy:Seq[(String, String)] = Nil): HalResourceHelper = {

    val response = requests.agencyGetSentInvitations(arn, filteredBy)
    require(response.status == 200, s"Couldn't get invitations, response status [${response.status}]")
    HalTestHelpers(response.json)
  }

  def sentInvitation(invitationId:String): HalResourceHelper = {
    val response = requests.agencyGetSentInvitation(arn, invitationId)
    require(response.status == 200, s"Couldn't get invitations, response status [${response.status}]")
    HalTestHelpers(response.json)
  }

  def cancelInvitation(invitation: EmbeddedInvitation): HttpResponse = {
    invitation.links.cancelLink.map { cancelLink =>
      val response: HttpResponse = new Resource(cancelLink, port).putEmpty()(hc)
      require(response.status == 204, s"response for canceling invitation should be 204, was [${response.status}]")
      response
    } .getOrElse (throw new IllegalStateException("Can't cancel this invitation the cancel link is not defined"))
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.support

import uk.gov.hmrc.domain.{AgentCode, Nino}
import uk.gov.hmrc.play.http.HttpResponse
import uk.gov.hmrc.play.test.UnitSpec
import uk.gov.hmrc.agentinvitations.controllers.ErrorResults._

trait SecuredEndpointBehaviours extends AkkaMaterializerSpec {
  this: UnitSpec with AppAndStubs   =>


  def anEndpointAccessibleForMtdAgentsOnly(makeRequest: => HttpResponse): Unit = {
    "return 401 when the requester is an Agent but not authenticated" in {
      given().agentAdmin(RandomArn(), AgentCode("tehCode")).isNotLoggedIn()
      makeRequest.status shouldBe 401
      makeRequest.body shouldBe bodyOf(GenericUnauthorized)
    }

    "return 403 Forbidden when the requester is a logged as a NON MTD Agent" in {
      given().agentAdmin(RandomArn(), AgentCode("tehCode")).isLoggedIn().andIsNotSubscribedToAgentServices()
      makeRequest.status shouldBe 403
      makeRequest.body shouldBe bodyOf(AgentNotSubscribed)
    }
  }

  def anEndpointAccessibleForSaClientsOnly(id: Nino)(makeRequest: => HttpResponse): Unit = {
    "return 401 when the requester is not authenticated" in {
      given().client(clientId = id).isNotLoggedIn()
      makeRequest.status shouldBe 401
      makeRequest.body shouldBe bodyOf(GenericUnauthorized)
    }

  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.support

import uk.gov.hmrc.agentinvitations.support.EmbeddedSection.EmbeddedInvitation
import uk.gov.hmrc.agentinvitations.support.HalTestHelpers.HalResourceHelper
import uk.gov.hmrc.domain.Nino
import uk.gov.hmrc.play.http.{HeaderCarrier, HttpResponse}
import uk.gov.hmrc.play.http.logging.SessionId

class ClientRequests(val requests: Requests, val clientId: Nino, implicit val port: Int) {

  implicit val hc: HeaderCarrier = HeaderCarrier(sessionId = Some(SessionId(clientId.value)))

  def acceptInvitation(invitation: EmbeddedInvitation): HttpResponse = {
    invitation.links.acceptLink.map (requests.updateInvitationResource)
      .getOrElse (throw new IllegalStateException("Can't accept this invitation the accept link is not defined"))
  }

  def rejectInvitation(invitation: EmbeddedInvitation): HttpResponse = {
    invitation.links.rejectLink.map(requests.updateInvitationResource)
      .getOrElse (throw new IllegalStateException("Can't reject this invitation the reject link is not defined"))
  }

  def getInvitations(filteredBy: Seq[(String, String)] = Nil): HalResourceHelper = {
    val response = requests.clientGetReceivedInvitations(clientId, filteredBy)(port, hc)
    require(response.status == 200, s"Couldn't get invitations, response status [${response.status}]")
    HalTestHelpers(response.json)
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.support

import uk.gov.hmrc.agentinvitations.stubs._
import uk.gov.hmrc.agentmtdidentifiers.model.Arn
import uk.gov.hmrc.domain.{AgentCode, Generator, Nino}

trait StubUtils {
  me: StartAndStopWireMock =>

  class PreconditionBuilder {

    def agentAdmin(arn: String, agentCode: String): AgentAdmin = {
      AgentAdmin(arn, oid = "556737e15500005500eaf68e", agentCode)
    }

    def agentAdmin(arn: Arn, agentCode: AgentCode): AgentAdmin = {
      agentAdmin(arn.value, agentCode.value)
    }

    def user(oid: String = "1234567890abcdef00000000"): UnknownUser = {
      UnknownUser(oid)
    }

    def client(oid: String = "556737e15500005500eaf68f", clientId: Nino = new Generator().nextNino): Client = {
      Client(oid, clientId)
    }
  }

  def given() = {
    new PreconditionBuilder()
  }

  class BaseUser extends WiremockAware {
    override def wiremockBaseUrl: String = me.wiremockBaseUrl
  }

  case class AgentAdmin(
                         override val arn: String,
                         override val oid: String,
                         override val agentCode: String)
    extends BaseUser with AgentAuthStubs[AgentAdmin] {
  }

  case class UnknownUser(override val oid: String)
    extends BaseUser with UnknownUserAuthStubs[UnknownUser]

  case class Client(override val oid: String, override val clientId: Nino)
    extends BaseUser with ClientUserAuthStubs[Client] with RelationshipStubs[Client] with DesStubs[Client]
} 

//设置package包名称以及导入依赖的类
package stubs

import com.github.tomakehurst.wiremock.WireMockServer
import com.github.tomakehurst.wiremock.client.WireMock
import com.github.tomakehurst.wiremock.client.WireMock._
import com.github.tomakehurst.wiremock.core.WireMockConfiguration
import play.api.http.Status._
import uk.gov.hmrc.domain.Nino

trait ApiPlatformTestUserStub {
  val mock: WireMock

  def willReturnTheIndividual(nino: Nino) = {
    mock.register(get(urlPathEqualTo(s"/individuals/nino/$nino"))
        .willReturn(aResponse().withStatus(OK).withBody(
          s"""
             |{
             |  "individualDetails": {
             |    "firstName": "Heather",
             |    "lastName": "Ling",
             |    "dateOfBirth": "1983-09-18"
             |  },
             |  "nino": "WC885133C"
             |}
           """.stripMargin)))
  }

  def willNotFindTheIndividual() = {
    mock.register(get(urlPathMatching("/individuals/nino/([A-Z0-9]+)"))
        .willReturn(aResponse().withStatus(NOT_FOUND)))
  }

  def willReturnAnError() = {
    mock.register(get(urlPathMatching("/individuals/nino/([A-Z0-9]+)"))
        .willReturn(aResponse().withStatus(INTERNAL_SERVER_ERROR)))
  }
}

object ApiPlatformTestUserStub extends ApiPlatformTestUserStub {
  val port = 11112
  val server = new WireMockServer(WireMockConfiguration.wireMockConfig().port(port))
  val mock = new WireMock("localhost", port)
  val url = s"http://localhost:$port"
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.scenarios

import org.scalatest._
import org.scalatest.concurrent.Eventually
import uk.gov.hmrc.agentinvitations.support.{AgencyRequests, MongoAppAndStubs, RandomArn, ScenarioHelpers}
import uk.gov.hmrc.domain.{AgentCode, Nino}


class AgencyFiltersByServicePlatformISpec extends FeatureSpec with ScenarioHelpers with GivenWhenThen with Matchers with MongoAppAndStubs with Inspectors with Inside with Eventually {

  implicit val arn = RandomArn()
  private implicit val agentCode = AgentCode("LMNOP123456")
  val nino: Nino = nextNino

  feature("Agencies can filter")  {

    scenario("on the service of invitations") {
      val agency = new AgencyRequests(this, arn, port)
      Given("An agent is logged in")
      given().agentAdmin(arn, agentCode).isLoggedInWithSessionId().andIsSubscribedToAgentServices()
      given().client(clientId = nino).hasABusinessPartnerRecord()

      When("An agent sends several invitations")
      agencySendsSeveralInvitations(agency)(
        (nino, MtdItService),
        (nino, MtdItService)
      )

      Then("The agent filters by HMRC-MTD-IT")
      agencyFiltersByMtdIt(agency)

      Then("The agent filters by mtd-vat")
      agencyFiltersByMtdVat(agency)
    }
  }

  def agencyFiltersByMtdIt(agency: AgencyRequests) = {
    val invitations = agency.sentInvitations(filteredBy = Seq("service" -> MtdItService))

    invitations.numberOfInvitations shouldBe 2
  }

  def agencyFiltersByMtdVat(agency: AgencyRequests) = {
    val invitations = agency.sentInvitations(filteredBy = Seq("service" -> "mtd-vat"))

    invitations.numberOfInvitations shouldBe 0
  }
}