// Copyright 2017 Google Inc.
//
// Licensed 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 accessEntity

import (
	"encoding/json"
	"github.com/apid/apidVerifyApiKey/common"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
	"time"
)

const (
	apiTestUrl = "http://127.0.0.1:9000"
)

var _ = Describe("API Tests", func() {
	var apiMan *ApiManager
	testCount := 0
	client := &http.Client{}
	dbMan := &DummyDbMan{}
	var attrs []common.Attribute
	var testId string
	clientGet := func(path string, pars map[string][]string) (int, []byte) {
		uri, err := url.Parse(apiTestUrl + path)
		Expect(err).Should(Succeed())
		query := url.Values(pars)
		uri.RawQuery = query.Encode()
		httpReq, err := http.NewRequest("GET", uri.String(), nil)
		Expect(err).Should(Succeed())
		res, err := client.Do(httpReq)
		Expect(err).Should(Succeed())
		defer res.Body.Close()
		responseBody, err := ioutil.ReadAll(res.Body)
		Expect(err).Should(Succeed())
		return res.StatusCode, responseBody
	}

	BeforeEach(func() {
		testCount++
		testId = "test-" + strconv.Itoa(testCount)
		apiMan = &ApiManager{
			DbMan:            dbMan,
			AccessEntityPath: AccessEntityPath + strconv.Itoa(testCount),
			apiInitialized:   false,
		}
		attrs = setAttrs(dbMan, testId)
		apiMan.InitAPI()
		time.Sleep(100 * time.Millisecond)
	})

	It("ApiProduct", func() {
		testProd := []common.ApiProduct{
			{
				Id:            testId,
				Name:          "apstest",
				DisplayName:   "apstest",
				Description:   "",
				ApiResources:  "{/**}",
				ApprovalType:  "AUTO",
				Scopes:        `{foo,bar}`,
				Proxies:       `{aps,perfBenchmark}`,
				Environments:  `{prod,test}`,
				Quota:         "10000000",
				QuotaTimeUnit: "MINUTE",
				QuotaInterval: 1,
				CreatedAt:     "2017-08-18 22:12:49.363+00:00",
				CreatedBy:     "haoming@apid.git",
				UpdatedAt:     "2017-08-18 22:26:50.153+00:00",
				UpdatedBy:     "haoming@apid.git",
				TenantId:      "515211e9",
			},
		}

		expected := ApiProductSuccessResponse{
			ApiProduct: &ApiProductDetails{
				ApiProxies:     []string{"aps", "perfBenchmark"},
				ApiResources:   []string{"/**"},
				ApprovalType:   testProd[0].ApprovalType,
				Attributes:     attrs,
				CreatedAt:      testProd[0].CreatedAt,
				CreatedBy:      testProd[0].CreatedBy,
				Description:    testProd[0].Description,
				DisplayName:    testProd[0].DisplayName,
				Environments:   []string{"prod", "test"},
				ID:             testProd[0].Id,
				LastModifiedAt: testProd[0].UpdatedAt,
				LastModifiedBy: testProd[0].UpdatedBy,
				Name:           testProd[0].Name,
				QuotaInterval:  testProd[0].QuotaInterval,
				QuotaLimit:     10000000,
				QuotaTimeUnit:  testProd[0].QuotaTimeUnit,
				Scopes:         []string{"foo", "bar"},
			},
			Organization:             "test-org",
			PrimaryIdentifierType:    IdentifierAppName,
			PrimaryIdentifierValue:   "test-app",
			SecondaryIdentifierType:  IdentifierDeveloperId,
			SecondaryIdentifierValue: "test-dev",
		}

		testData := [][]common.ApiProduct{
			testProd,
			nil,
			testProd,
			testProd,
		}

		testPars := []map[string][]string{
			// positive
			{
				IdentifierOrganization: {"test-org"},
				IdentifierAppName:      {"test-app"},
				IdentifierDeveloperId:  {"test-dev"},
			},
			// negative
			{
				IdentifierOrganization: {"test-org"},
				IdentifierAppName:      {"test-app"},
				IdentifierDeveloperId:  {"test-dev"},
			},
			{
				IdentifierAppName:     {"test-app"},
				IdentifierDeveloperId: {"test-dev"},
			},
			{
				IdentifierDeveloperId: {"test-dev"},
			},
		}

		results := [][]interface{}{
			{http.StatusOK, expected},
			{http.StatusNotFound, nil},
			{http.StatusBadRequest, nil},
			{http.StatusBadRequest, nil},
		}

		for i, data := range testData {
			dbMan.apiProducts = data
			code, body := clientGet(apiMan.AccessEntityPath+EndpointApiProduct, testPars[i])
			Expect(code).Should(Equal(results[i][0]))
			if results[i][1] != nil {
				var res ApiProductSuccessResponse
				Expect(json.Unmarshal(body, &res)).Should(Succeed())
				Expect(res).Should(Equal(results[i][1]))
			}
		}

	})

	It("Apps", func() {
		testApp := []common.App{
			{
				Id:          testId,
				TenantId:    "515211e9",
				Name:        "apstest",
				DisplayName: "apstest",
				AccessType:  "READ",
				CallbackUrl: "https://www.google.com",
				Status:      "APPROVED",
				AppFamily:   "default",
				CompanyId:   "",
				DeveloperId: "e41f04e8-9d3f-470a-8bfd-c7939945896c",
				ParentId:    "e41f04e8-9d3f-470a-8bfd-c7939945896c",
				Type:        "DEVELOPER",
				CreatedAt:   "2017-08-18 22:13:18.325+00:00",
				CreatedBy:   "haoming@apid.git",
				UpdatedAt:   "2017-08-18 22:13:18.325+00:00",
				UpdatedBy:   "haoming@apid.git",
			},
		}

		testProductNames := []string{"foo", "bar"}
		testStatus := "test-status"
		testCreds := []common.AppCredential{
			{
				Id:             testId,
				TenantId:       "515211e9",
				ConsumerSecret: "secret1",
				AppId:          testId,
				MethodType:     "GET",
				Status:         "APPROVED",
				IssuedAt:       "2017-08-18 22:13:18.35+00:00",
				ExpiresAt:      "2018-08-18 22:13:18.35+00:00",
				AppStatus:      "APPROVED",
				Scopes:         "{foo,bar}",
				CreatedAt:      "2017-08-18 22:13:18.35+00:00",
				CreatedBy:      "-NA-",
				UpdatedAt:      "2017-08-18 22:13:18.352+00:00",
				UpdatedBy:      "-NA-",
			},
		}
		expected := AppSuccessResponse{
			App: &AppDetails{
				AccessType:  testApp[0].AccessType,
				ApiProducts: testProductNames,
				AppCredentials: []*CredentialDetails{
					{
						ApiProductReferences: testProductNames,
						AppID:                testCreds[0].AppId,
						AppStatus:            testApp[0].Status,
						Attributes:           attrs,
						ConsumerKey:          testCreds[0].Id,
						ConsumerSecret:       testCreds[0].ConsumerSecret,
						ExpiresAt:            testCreds[0].ExpiresAt,
						IssuedAt:             testCreds[0].IssuedAt,
						MethodType:           testCreds[0].MethodType,
						Scopes:               []string{"foo", "bar"},
						Status:               testCreds[0].Status,
					},
				},
				AppFamily:       testApp[0].AppFamily,
				AppParentID:     testApp[0].ParentId,
				AppParentStatus: testStatus,
				AppType:         testApp[0].Type,
				Attributes:      attrs,
				CallbackUrl:     testApp[0].CallbackUrl,
				CreatedAt:       testApp[0].CreatedAt,
				CreatedBy:       testApp[0].CreatedBy,
				DisplayName:     testApp[0].DisplayName,
				Id:              testApp[0].Id,
				KeyExpiresIn:    "", //TODO
				LastModifiedAt:  testApp[0].UpdatedAt,
				LastModifiedBy:  testApp[0].UpdatedBy,
				Name:            testApp[0].Name,
				Scopes:          []string{}, //TODO
				Status:          testApp[0].Status,
			},
			Organization:             "test-org",
			PrimaryIdentifierType:    IdentifierAppName,
			PrimaryIdentifierValue:   "test-app",
			SecondaryIdentifierType:  IdentifierDeveloperId,
			SecondaryIdentifierValue: "test-dev",
		}

		testData := [][]common.App{
			testApp,
			nil,
			testApp,
			testApp,
		}

		testPars := []map[string][]string{
			// positive
			{
				IdentifierOrganization: {"test-org"},
				IdentifierAppName:      {"test-app"},
				IdentifierDeveloperId:  {"test-dev"},
			},
			// negative
			{
				IdentifierOrganization: {"test-org"},
				IdentifierAppName:      {"test-app"},
				IdentifierDeveloperId:  {"test-dev"},
			},
			{
				IdentifierAppName:     {"test-app"},
				IdentifierDeveloperId: {"test-dev"},
			},
			{
				IdentifierDeveloperId: {"test-dev"},
			},
		}

		results := [][]interface{}{
			{http.StatusOK, expected},
			{http.StatusNotFound, nil},
			{http.StatusBadRequest, nil},
			{http.StatusBadRequest, nil},
		}

		dbMan.apiProductNames = testProductNames
		dbMan.status = testStatus
		dbMan.appCredentials = testCreds
		for i, data := range testData {
			dbMan.apps = data
			code, body := clientGet(apiMan.AccessEntityPath+EndpointApp, testPars[i])
			Expect(code).Should(Equal(results[i][0]))
			if results[i][1] != nil {
				var res AppSuccessResponse
				Expect(json.Unmarshal(body, &res)).Should(Succeed())
				Expect(res).Should(Equal(results[i][1]))
			}
		}

	})

	It("Company", func() {
		testCom := []common.Company{
			{
				Id:          testId,
				TenantId:    "515211e9",
				Name:        "testcompanyhflxv",
				DisplayName: "testcompanyhflxv",
				Status:      "ACTIVE",
				CreatedAt:   "2017-11-02 16:00:16.287+00:00",
				CreatedBy:   "haoming@apid.git",
				UpdatedAt:   "2017-11-02 16:00:16.287+00:00",
				UpdatedBy:   "haoming@apid.git",
			},
		}

		testAppNames := []string{"foo", "bar"}

		expected := CompanySuccessResponse{
			Company: &CompanyDetails{
				Apps:           testAppNames,
				Attributes:     attrs,
				CreatedAt:      testCom[0].CreatedAt,
				CreatedBy:      testCom[0].CreatedBy,
				DisplayName:    testCom[0].DisplayName,
				ID:             testCom[0].Id,
				LastModifiedAt: testCom[0].UpdatedAt,
				LastModifiedBy: testCom[0].UpdatedBy,
				Name:           testCom[0].Name,
				Status:         testCom[0].Status,
			},
			Organization:           "test-org",
			PrimaryIdentifierType:  IdentifierAppId,
			PrimaryIdentifierValue: "test-app",
		}

		testData := [][]common.Company{
			testCom,
			nil,
			testCom,
			testCom,
		}

		testPars := []map[string][]string{
			// positive
			{
				IdentifierOrganization: {"test-org"},
				IdentifierAppId:        {"test-app"},
			},
			// negative
			{
				IdentifierOrganization: {"test-org"},
				IdentifierAppId:        {"test-app"},
			},
			{
				IdentifierAppId: {"test-app"},
			},
			{
				IdentifierDeveloperId: {"test-dev"},
			},
		}

		results := [][]interface{}{
			{http.StatusOK, expected},
			{http.StatusNotFound, nil},
			{http.StatusBadRequest, nil},
			{http.StatusBadRequest, nil},
		}

		dbMan.appNames = testAppNames

		for i, data := range testData {
			dbMan.companies = data
			code, body := clientGet(apiMan.AccessEntityPath+EndpointCompany, testPars[i])
			Expect(code).Should(Equal(results[i][0]))
			if results[i][1] != nil {
				var res CompanySuccessResponse
				Expect(json.Unmarshal(body, &res)).Should(Succeed())
				Expect(res).Should(Equal(results[i][1]))
			}
		}

	})

	It("Developer", func() {
		testDev := []common.Developer{
			{
				Id:                testId,
				TenantId:          "515211e9",
				UserName:          "haoming",
				FirstName:         "haoming",
				LastName:          "zhang",
				Password:          "111",
				Email:             "bar@google.com",
				Status:            "ACTIVE",
				EncryptedPassword: "222",
				Salt:              "333",
				CreatedAt:         "2017-08-16 22:39:46.669+00:00",
				CreatedBy:         "foo@google.com",
				UpdatedAt:         "2017-08-16 22:39:46.669+00:00",
				UpdatedBy:         "foo@google.com",
			},
		}

		testAppNames := []string{"foo", "bar"}
		testComNames := []string{"foo", "bar"}

		expected := DeveloperSuccessResponse{
			Developer: &DeveloperDetails{
				Apps:           testAppNames,
				Attributes:     attrs,
				Companies:      testComNames,
				CreatedAt:      testDev[0].CreatedAt,
				CreatedBy:      testDev[0].CreatedBy,
				Email:          testDev[0].Email,
				FirstName:      testDev[0].FirstName,
				ID:             testDev[0].Id,
				LastModifiedAt: testDev[0].UpdatedAt,
				LastModifiedBy: testDev[0].UpdatedBy,
				LastName:       testDev[0].LastName,
				Password:       testDev[0].Password,
				Status:         testDev[0].Status,
				UserName:       testDev[0].UserName,
			},
			Organization:           "test-org",
			PrimaryIdentifierType:  IdentifierAppId,
			PrimaryIdentifierValue: "test-app",
		}

		testData := [][]common.Developer{
			testDev,
			nil,
			testDev,
			testDev,
		}

		testPars := []map[string][]string{
			// positive
			{
				IdentifierOrganization: {"test-org"},
				IdentifierAppId:        {"test-app"},
			},
			// negative
			{
				IdentifierOrganization: {"test-org"},
				IdentifierAppId:        {"test-app"},
			},
			{
				IdentifierAppId: {"test-app"},
			},
			{
				IdentifierDeveloperId: {"test-dev"},
			},
		}

		results := [][]interface{}{
			{http.StatusOK, expected},
			{http.StatusNotFound, nil},
			{http.StatusBadRequest, nil},
			{http.StatusBadRequest, nil},
		}

		dbMan.appNames = testAppNames
		dbMan.comNames = testComNames

		for i, data := range testData {
			dbMan.developers = data
			code, body := clientGet(apiMan.AccessEntityPath+EndpointDeveloper, testPars[i])
			Expect(code).Should(Equal(results[i][0]))
			if results[i][1] != nil {
				var res DeveloperSuccessResponse
				Expect(json.Unmarshal(body, &res)).Should(Succeed())
				Expect(res).Should(Equal(results[i][1]))
			}
		}

	})

	It("AppCredential", func() {
		testAppCred := []common.AppCredential{
			{
				Id:             testId,
				TenantId:       "515211e9",
				ConsumerSecret: "secret1",
				AppId:          testId,
				MethodType:     "GET",
				Status:         "APPROVED",
				IssuedAt:       "2017-08-18 22:13:18.35+00:00",
				ExpiresAt:      "2018-08-18 22:13:18.35+00:00",
				AppStatus:      "APPROVED",
				Scopes:         "{foo,bar}",
				CreatedAt:      "2017-08-18 22:13:18.35+00:00",
				CreatedBy:      "-NA-",
				UpdatedAt:      "2017-08-18 22:13:18.352+00:00",
				UpdatedBy:      "-NA-",
			},
		}
		testApp := []common.App{
			{
				Id:          testId,
				TenantId:    "515211e9",
				Name:        "apstest",
				DisplayName: "apstest",
				AccessType:  "READ",
				CallbackUrl: "https://www.google.com",
				Status:      "APPROVED",
				AppFamily:   "default",
				CompanyId:   "",
				DeveloperId: "e41f04e8-9d3f-470a-8bfd-c7939945896c",
				ParentId:    "e41f04e8-9d3f-470a-8bfd-c7939945896c",
				Type:        "DEVELOPER",
				CreatedAt:   "2017-08-18 22:13:18.325+00:00",
				CreatedBy:   "haoming@apid.git",
				UpdatedAt:   "2017-08-18 22:13:18.325+00:00",
				UpdatedBy:   "haoming@apid.git",
			},
		}

		testProductNames := []string{"foo", "bar"}
		testStatus := "test-status"

		expected := AppCredentialSuccessResponse{
			AppCredential: &AppCredentialDetails{
				AppID:       testAppCred[0].AppId,
				AppName:     testApp[0].Name,
				Attributes:  attrs,
				ConsumerKey: testAppCred[0].Id,
				ConsumerKeyStatus: &ConsumerKeyStatusDetails{
					AppCredential: &CredentialDetails{
						ApiProductReferences: testProductNames,
						AppID:                testAppCred[0].AppId,
						AppStatus:            testApp[0].Status,
						Attributes:           attrs,
						ConsumerKey:          testAppCred[0].Id,
						ConsumerSecret:       testAppCred[0].ConsumerSecret,
						ExpiresAt:            testAppCred[0].ExpiresAt,
						IssuedAt:             testAppCred[0].IssuedAt,
						MethodType:           testAppCred[0].MethodType,
						Scopes:               []string{"foo", "bar"},
						Status:               testAppCred[0].Status,
					},
					AppID:           testAppCred[0].AppId,
					AppName:         testApp[0].Name,
					AppStatus:       testApp[0].Status,
					AppType:         testApp[0].Type,
					DeveloperID:     testApp[0].DeveloperId,
					DeveloperStatus: testStatus,
					IsValidKey:      true,
				},
				ConsumerSecret: testAppCred[0].ConsumerSecret,
				DeveloperID:    testApp[0].DeveloperId,
				RedirectUris:   []string{testApp[0].CallbackUrl}, //TODO
				Scopes:         []string{"foo", "bar"},
				Status:         testAppCred[0].Status,
			},
			Organization:           "test-org",
			PrimaryIdentifierType:  IdentifierConsumerKey,
			PrimaryIdentifierValue: "test-key",
		}

		testData := [][]common.AppCredential{
			testAppCred,
			nil,
			testAppCred,
			testAppCred,
		}

		testPars := []map[string][]string{
			// positive
			{
				IdentifierOrganization: {"test-org"},
				IdentifierConsumerKey:  {"test-key"},
			},
			// negative
			{
				IdentifierOrganization: {"test-org"},
				IdentifierConsumerKey:  {"test-key"},
			},
			{
				IdentifierConsumerKey: {"test-key"},
			},
			{
				IdentifierDeveloperId: {"test-dev"},
			},
		}

		results := [][]interface{}{
			{http.StatusOK, expected},
			{http.StatusNotFound, nil},
			{http.StatusBadRequest, nil},
			{http.StatusBadRequest, nil},
		}

		dbMan.apiProductNames = testProductNames
		dbMan.status = testStatus
		dbMan.apps = testApp
		for i, data := range testData {
			dbMan.appCredentials = data
			code, body := clientGet(apiMan.AccessEntityPath+EndpointAppCredentials, testPars[i])
			Expect(code).Should(Equal(results[i][0]))
			if results[i][1] != nil {
				var res AppCredentialSuccessResponse
				Expect(json.Unmarshal(body, &res)).Should(Succeed())
				Expect(res).Should(Equal(results[i][1]))
			}
		}
	})

	It("CompanyDeveloper", func() {
		testDev := []common.CompanyDeveloper{
			{
				TenantId:    "515211e9",
				CompanyId:   "a94f75e2-69b0-44af-8776-155df7c7d22e",
				DeveloperId: "590f33bf-f05c-48c1-bb93-183759bd9ee1",
				Roles:       "{foo,bar}",
				CreatedAt:   "2017-11-02 16:00:16.287+00:00",
				CreatedBy:   "haoming@apid.git",
				UpdatedAt:   "2017-11-02 16:00:16.287+00:00",
				UpdatedBy:   "haoming@apid.git",
			},
		}

		testComNames := []string{"foo"}
		testEmail := "haoming@apid.git"

		expected := CompanyDevelopersSuccessResponse{
			CompanyDevelopers: []*CompanyDeveloperDetails{
				{
					CompanyName:    testComNames[0],
					CreatedAt:      testDev[0].CreatedAt,
					CreatedBy:      testDev[0].CreatedBy,
					DeveloperEmail: testEmail,
					LastModifiedAt: testDev[0].UpdatedAt,
					LastModifiedBy: testDev[0].UpdatedBy,
					Roles:          []string{"foo", "bar"},
				},
			},
			Organization:           "test-org",
			PrimaryIdentifierType:  IdentifierCompanyName,
			PrimaryIdentifierValue: "test-com",
		}

		testData := [][]common.CompanyDeveloper{
			testDev,
			nil,
			testDev,
			testDev,
		}

		testPars := []map[string][]string{
			// positive
			{
				IdentifierOrganization: {"test-org"},
				IdentifierCompanyName:  {"test-com"},
			},
			// negative
			{
				IdentifierOrganization: {"test-org"},
				IdentifierCompanyName:  {"test-com"},
			},
			{
				IdentifierCompanyName: {"test-com"},
			},
			{
				IdentifierDeveloperId: {"test-dev"},
			},
		}

		results := [][]interface{}{
			{http.StatusOK, expected},
			{http.StatusNotFound, nil},
			{http.StatusBadRequest, nil},
			{http.StatusBadRequest, nil},
		}

		dbMan.comNames = testComNames
		dbMan.email = testEmail

		for i, data := range testData {
			dbMan.companyDevelopers = data
			code, body := clientGet(apiMan.AccessEntityPath+EndpointCompanyDeveloper, testPars[i])
			Expect(code).Should(Equal(results[i][0]))
			if results[i][1] != nil {
				var res CompanyDevelopersSuccessResponse
				Expect(json.Unmarshal(body, &res)).Should(Succeed())
				Expect(res).Should(Equal(results[i][1]))
			}
		}

	})
})

func setAttrs(dbMan *DummyDbMan, id string) []common.Attribute {
	dbMan.attrs = map[string][]common.Attribute{
		id: {
			{
				Name:  "foo",
				Value: "bar",
			},
			{
				Name:  "bar",
				Value: "foo",
			},
		},
	}
	return dbMan.attrs[id]
}