import { SF_PARAMS, HEADER_NAMES } from "./constants";
import { ResponseHandlers } from "./Requests/ExecutableRequest";
import { Sitefinity } from "./Sitefinity";

describe("Base SDK tests", () => {
    const baseUrl = "http://www.mysite.com/api/default/";
    const batchResponse = `--batchresponse_ab4d3fab-5bee-4ea0-ba40-723ea40d1c32\r
Content-Type: application/http\r
Content-Transfer-Encoding: binary\r
\r
HTTP/1.1 200 OK\r
Cache-Control: no-store, must-revalidate, no-cache\r
Access-Control-Allow-Origin: *\r
Content-Type: text/plain\r
OData-Version: 4.0\r
\r
1\r
--batchresponse_ab4d3fab-5bee-4ea0-ba40-723ea40d1c32--\r
`;
    let sitefinity: Sitefinity;

    beforeEach(() => {
        jasmine.Ajax.install();
    });

    afterEach(() => {
        jasmine.Ajax.uninstall();
    });

    beforeAll(() => {
        sitefinity = new Sitefinity({
            baseUrl
        });
    });

    describe("SDK options tests", () => {
        it("Verify baseUrl from SDK options wiht slash", () => {
            const url = "/";
            const sdk = new Sitefinity({
                baseUrl: url
            });
            sdk.data({}).get({});

            const request = jasmine.Ajax.requests.mostRecent();
            expect(request.url).toBe(url);
        });

        it("Verify baseUrl from SDK options with relative path", () => {
            const url = "/sub";
            const sdk = new Sitefinity({
                baseUrl: url
            });
            sdk.data({}).get({});

            const request = jasmine.Ajax.requests.mostRecent();
            expect(request.url).toBe(url + "/");
        });

        it("Verify baseUrl from SDK options with relative path and slash", () => {
            const url = "/sub/";
            const sdk = new Sitefinity({
                baseUrl: url
            });
            sdk.data({}).get({});

            const request = jasmine.Ajax.requests.mostRecent();
            expect(request.url).toBe(url);
        });

        it("Verify baseUrl from SDK options", () => {
            const url = "http://www.mysite.com/api/default/v2/";
            const sdk = new Sitefinity({
                baseUrl: url
            });
            sdk.data({}).get({});

            const request = jasmine.Ajax.requests.mostRecent();
            expect(request.url).toBe(url);
        });

        it("Verify siteId from SDK options", () => {
            const siteId = "mySiteId";
            const sdk = new Sitefinity({
                baseUrl: "http://www.mysite.com/api/default/v2/",
                siteId: siteId
            });
            sdk.data({}).get({});

            const request = jasmine.Ajax.requests.mostRecent();
            expect(request.url).toContain(`${SF_PARAMS.siteId}=${siteId}`);
        });

        it("Verify enableUnlimitedChoices from SDK options", () => {
            let sdk = new Sitefinity({
                baseUrl: "http://www.mysite.com/api/default/v2/",
                enableUnlimitedChoices: true
            });
            sdk.data({}).get({});

            let request = jasmine.Ajax.requests.mostRecent();
            expect(request.requestHeaders[HEADER_NAMES.choicesBinaryRepresentation]).toBe("true");

            sdk = new Sitefinity({
                baseUrl: "http://www.mysite.com/api/default/v2/",
                enableUnlimitedChoices: false
            });
            sdk.data({}).get({});

            request = jasmine.Ajax.requests.mostRecent();
            expect(request.requestHeaders[HEADER_NAMES.choicesBinaryRepresentation]).toBeUndefined();
        });

        it("Verify integrationMode from SDK options", () => {
            let sdk = new Sitefinity({
                baseUrl: "http://www.mysite.com/api/default/v2/",
                integrationMode: true
            });
            sdk.data({}).get({});

            let request = jasmine.Ajax.requests.mostRecent();
            expect(request.requestHeaders[HEADER_NAMES.integrationMode]).toBe("true");

            sdk = new Sitefinity({
                baseUrl: "http://www.mysite.com/api/default/v2/",
                integrationMode: false
            });
            sdk.data({}).get({});

            request = jasmine.Ajax.requests.mostRecent();
            expect(request.requestHeaders[HEADER_NAMES.integrationMode]).toBeUndefined();
        });

        it("Verify global success handler from SDK options", () => {
            const handlers: ResponseHandlers = {
                successCb: () => {},
                failureCb: () => {}
            };
            const successSpy = spyOn<ResponseHandlers, any>(handlers, "successCb");
            const failureSpy = spyOn<ResponseHandlers, any>(handlers, "failureCb");

            const sdk = new Sitefinity({
                baseUrl: "http://www.mysite.com/api/default/v2/",
                handlers
            });
            sdk.data({}).get({});

            const request = jasmine.Ajax.requests.mostRecent();
            request.respondWith({
                status: 200,
                responseText: "{\"message\":\"test\"}"
            });

            expect(successSpy).toHaveBeenCalledOnceWith({ message: "test" });
            expect(failureSpy).not.toHaveBeenCalled();
        });

        it("Verify global failure handler from SDK options", () => {
            const handlers: ResponseHandlers = {
                successCb: () => {},
                failureCb: () => {}
            };
            const successSpy = spyOn<ResponseHandlers, any>(handlers, "successCb");
            const failureSpy = spyOn<ResponseHandlers, any>(handlers, "failureCb");

            const sdk = new Sitefinity({
                baseUrl: "http://www.mysite.com/api/default/v2/",
                handlers
            });
            sdk.data({}).get({});

            const request = jasmine.Ajax.requests.mostRecent();
            request.respondWith({
                status: 400,
                responseText: "{\"message\":\"test\"}"
            });

            expect(failureSpy).toHaveBeenCalledOnceWith({ message: "test", status: 400 });
            expect(successSpy).not.toHaveBeenCalled();
        });

        it("Verify token", () => {
            const sdk = new Sitefinity({
                baseUrl: "http://www.mysite.com/api/default/v2/"
            });
            sdk.data({}).get({});

            let request = jasmine.Ajax.requests.mostRecent();
            expect(request.requestHeaders[HEADER_NAMES.authorization]).toBeUndefined();

            sdk.setToken({
                type: "Bearer",
                value: "123"
            });
            sdk.data({}).get({});

            request = jasmine.Ajax.requests.mostRecent();
            expect(request.requestHeaders[HEADER_NAMES.authorization]).toBe("Bearer 123");
        });
    });

    describe("Type options tests", () => {
        describe("for data()", () => {
            it("Verify baseUrl is appended trailing slash", () => {
                const url = "http://www.mysite.com/api/default/v2";
                sitefinity.data({
                    baseUrl: url
                }).get({});

                let request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toBe(`${url}/`);

                const sdk = new Sitefinity({
                    baseUrl: url
                });
                sdk.data({}).get({});

                request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toBe(`${url}/`);
            });

            it("Verify baseUrl from type options overrides baseUrl from SDK options", () => {
                const url = "http://www.mysite.com/api/default/v2/";
                sitefinity.data({
                    baseUrl: url
                }).get({});

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toBe(url);
            });

            it("Verify siteId from type options overrides siteId from SDK options", () => {
                const siteId = "mySiteId";
                const sdk = new Sitefinity({
                    baseUrl: "http://www.mysite.com/api/default/v2/",
                    siteId: "test"
                });
                sdk.data({
                    siteId
                }).get({});

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toContain(`${SF_PARAMS.siteId}=${siteId}`);
            });

            it("Verify entitySet from type options", () => {
                const entitySet = "newsitems";

                sitefinity.data({
                    entitySet
                }).get({});

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toBe(`${baseUrl}${entitySet}`);
            });

            it("Verify provider from type options", () => {
                const provider = "myProvider";

                sitefinity.data({
                    provider
                }).get({});

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toContain(`${SF_PARAMS.provider}=${provider}`);
            });

            it("Verify culture from type options", () => {
                const culture = "en";

                sitefinity.data({
                    culture
                }).get({});

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toContain(`${SF_PARAMS.culture}=${culture}`);
            });

            it("Verify additional query params from type options", () => {
                const additionalQueryParams = {
                    "p1": "test1",
                    "p2": "123",
                };

                sitefinity.data({
                    additionalQueryParams
                }).get({});

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toContain("p1=test1&p2=123");
            });

            it("Verify additional headers from type options", () => {
                const additionalHeaders = {
                    "p1": "test1",
                    "p2": "123",
                };

                sitefinity.data({
                    additionalHeaders
                }).get({});

                additionalHeaders[HEADER_NAMES.serviceRequest] = "true";

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.requestHeaders).toEqual(additionalHeaders);
            });
        });

        describe("for batch", () => {
            it("Verify baseUrl is appended trailing slash", () => {
                const url = "http://www.mysite.com/api/default/v2";
                sitefinity.batch(undefined, undefined, undefined, {
                    baseUrl: url
                }).execute();

                let request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toBe(`${url}/$batch`);

                const sdk = new Sitefinity({
                    baseUrl: url
                });
                sdk.batch().execute();

                request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toBe(`${url}/$batch`);
            });

            it("Verify baseUrl from type options overrides baseUrl from SDK options", () => {
                const url = "http://www.mysite.com/api/default/v2/";
                sitefinity.batch(undefined, undefined, undefined, {
                    baseUrl: url
                }).execute();

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toBe(`${url}$batch`);
            });

            it("Verify siteId from type options overrides siteId from SDK options", () => {
                const siteId = "mySiteId";
                const sdk = new Sitefinity({
                    baseUrl: "http://www.mysite.com/api/default/v2/",
                    siteId: "test"
                });
                sdk.batch(undefined, undefined, undefined, {
                    siteId
                }).execute();

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toContain(`${SF_PARAMS.siteId}=${siteId}`);
            });

            it("Verify provider from type options", () => {
                const provider = "myProvider";

                sitefinity.batch(undefined, undefined, undefined, {
                    provider
                }).execute();

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toContain(`${SF_PARAMS.provider}=${provider}`);
            });

            it("Verify culture from type options", () => {
                const culture = "en";

                sitefinity.batch(undefined, undefined, undefined, {
                    culture
                }).execute();

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toContain(`${SF_PARAMS.culture}=${culture}`);
            });

            it("Verify additional query params from type options", () => {
                const additionalQueryParams = {
                    "p1": "test1",
                    "p2": "123",
                };

                sitefinity.batch(undefined, undefined, undefined, {
                    additionalQueryParams
                }).execute();

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.url).toContain("p1=test1&p2=123");
            });

            it("Verify additional headers from type options", () => {
                const additionalHeaders = {
                    "p1": "test1",
                    "p2": "123",
                };

                sitefinity.batch(undefined, undefined, undefined, {
                    additionalHeaders
                }).execute();

                additionalHeaders[HEADER_NAMES.serviceRequest] = "true";

                const request = jasmine.Ajax.requests.mostRecent();
                expect(request.requestHeaders).toEqual(additionalHeaders);
            });

            it("Verify successCb overrides global success handler from SDK options", () => {
                const globalHandlers: ResponseHandlers = {
                    successCb: () => {},
                    failureCb: () => {}
                };
                const successSpyGlobal = spyOn<ResponseHandlers, any>(globalHandlers, "successCb");
                const failureSpyGlobal = spyOn<ResponseHandlers, any>(globalHandlers, "failureCb");

                const localHandlers = {
                    successCb: () => {},
                    failureCb: () => {}
                };
                const successSpyLocal = spyOn<ResponseHandlers, any>(localHandlers, "successCb");
                const failureSpyLocal = spyOn<ResponseHandlers, any>(localHandlers, "failureCb");

                const sdk = new Sitefinity({
                    baseUrl: "http://www.mysite.com/api/default/v2/",
                    handlers: globalHandlers
                });
                sdk.batch(localHandlers.successCb, localHandlers.failureCb).execute();

                const request = jasmine.Ajax.requests.mostRecent();
                request.respondWith({
                    status: 200,
                    responseText: batchResponse,
                    responseHeaders: {
                        "Access-Control-Allow-Origin": "*",
                        "Cache-Control:": "no-cache",
                        "Content-Length": "334",
                        "Content-type": "multipart/mixed; boundary=batchresponse_ab4d3fab-5bee-4ea0-ba40-723ea40d1c32"
                    }
                });

                expect(successSpyLocal).toHaveBeenCalledTimes(1);
                expect(failureSpyLocal).not.toHaveBeenCalled();
                expect(successSpyGlobal).not.toHaveBeenCalled();
                expect(failureSpyGlobal).not.toHaveBeenCalled();
            });

            it("Verify failureCb overrides global failure handler from SDK options", () => {
                const globalHandlers: ResponseHandlers = {
                    successCb: () => {},
                    failureCb: () => {}
                };
                const successSpyGlobal = spyOn<ResponseHandlers, any>(globalHandlers, "successCb");
                const failureSpyGlobal = spyOn<ResponseHandlers, any>(globalHandlers, "failureCb");

                const localHandlers = {
                    successCb: () => {},
                    failureCb: () => {}
                };
                const successSpyLocal = spyOn<ResponseHandlers, any>(localHandlers, "successCb");
                const failureSpyLocal = spyOn<ResponseHandlers, any>(localHandlers, "failureCb");

                const sdk = new Sitefinity({
                    baseUrl: "http://www.mysite.com/api/default/v2/",
                    handlers: globalHandlers
                });
                sdk.batch(localHandlers.successCb, localHandlers.failureCb).execute();

                const request = jasmine.Ajax.requests.mostRecent();
                request.respondWith({
                    status: 400,
                    responseText: batchResponse,
                    responseHeaders: {
                        "Access-Control-Allow-Origin": "*",
                        "Cache-Control:": "no-cache",
                        "Content-Length": "334",
                        "Content-type": "multipart/mixed; boundary=batchresponse_ab4d3fab-5bee-4ea0-ba40-723ea40d1c32"
                    }
                });

                expect(failureSpyLocal).toHaveBeenCalledTimes(1);
                expect(successSpyLocal).not.toHaveBeenCalled();
                expect(successSpyGlobal).not.toHaveBeenCalled();
                expect(failureSpyGlobal).not.toHaveBeenCalled();
            });
        });
    });
});