import { ChunkUploadSdk } from "./chunk-upload/chunk-upload.sdk";
import { SF_PARAMS } from "./constants";
import { Query } from "./Query";
import { ExecutableRequest } from "./Requests/ExecutableRequest";
import { RequestFactory } from "./Requests/RequestFactory";
import { TypeOptions } from "./Sitefinity";

/**
* The constructor of the Data object. This object is used for requesting data from Sitefinity.
*/
export class Data {
    private urlOptions: TypeOptions;
    private factory: RequestFactory;

    constructor(urlOptions: TypeOptions, factory: RequestFactory) {
        this.urlOptions = urlOptions;
        this.factory = factory;
    }


    /**
     * Returns an instance of the @type {ChunkUploadService}
     *
     * @readonly
     * @type {ChunkUploadSdk}
     * @memberof Data
     */
    public get chunkUpload(): ChunkUploadSdk {
        const service = new ChunkUploadSdk(this.urlOptions, this.factory);
        return service;
    }

    /**
    * Executes a GET request to retrieve a collection of items.
    */
    get(parameters: RequestOptionsBase) {
        const request = this.factory.get({
            urlOptions: this.urlOptions,
            query: parameters.query,
            action: parameters.action,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb,
            fallbackProperties: parameters.fallbackProperties
        });

        request.execute();
    }

    /**
    * Executes a GET request to retrieve an/all item(s) operations.
    */
    getOperations(parameters: OperationsRequestOptions) {
        let request: ExecutableRequest;
        let action = "operations";

        // Set parentId if no item key is passed
        if (!parameters.key)
            action += `?${SF_PARAMS.parentId}=` + parameters.parentId;

        const params: any = {
            urlOptions: this.urlOptions,
            action: action,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        };

        if (parameters.key) {
            params.key = parameters.key;
            request = this.factory.getSingle(params);
        } else {
            request = this.factory.get(params);
        }

        request.execute();
    }

    /**
    * Executes a GET request for a single item.
    */
    getSingle(parameters: RequestOptionsBase) {
        if (!(parameters.key))
            throw "Parameter 'key' is required!";

        const request = this.factory.getSingle({
            urlOptions: this.urlOptions,
            key: parameters.key,
            query: parameters.query,
            action: parameters.action,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb,
            fallbackProperties: parameters.fallbackProperties
        });

        request.execute();
    }

    /**
    * Executes a POST request for a single item.
    */
    create(parameters: CreateRequestOptions) {
        if (!(parameters.data))
            throw "Parameter 'data' is required!";

        const request = this.factory.create({
            urlOptions: this.urlOptions,
            key: parameters.key,
            query: parameters.query,
            data: parameters.data,
            action: parameters.action,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a PATCH request to update a single item.
    * @example
    * const data = sf.data({
    *     entitySet: "newsitems",
    *     provider: "OpenAccessDataProvider",
    *     culture: "en"
    * });
    *
    * const newsItemUpdate =  {
    *    "Title": 'updated news title'
    * };
    *
    * data.update({
    *   key: '00000000-0000-0000-0000-000000000000', // key of item to update
    *   data: newsItemUpdate,
    *   saveTemp: true,
    *   successCb: successCb,
    *   failureCb: failureCb
    * });
    */
    update(parameters: UpdateRequestOptions) {
        if (!(parameters.key || parameters.data))
            throw "Parameters: 'data' and 'key' are required!";

        const request = this.factory.update({
            urlOptions: this.urlOptions,
            key: parameters.key,
            data: parameters.data,
            action: parameters.action,
            saveTemp: parameters.saveTemp,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a DELETE request to delete a single item.
    */
    destroy(parameters: RequestOptionsBase) {
        if (!(parameters.key))
            throw "Parameter 'key' is required!";

        const request = this.factory.destroy({
            urlOptions: this.urlOptions,
            key: parameters.key,
            action: parameters.action,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a POST request to execute a workflow operation for single item.
    */
    operation(parameters: CreateRequestOptions) {
        if (!(parameters.key || parameters.data))
            throw "Parameters: 'data' and 'key' are required!";

        const request = this.factory.create({
            urlOptions: this.urlOptions,
            key: parameters.key,
            action: "operation",
            data: parameters.data,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a GET request to get the property of a single item.
    */
    getProperty(parameters: PropertyRequestOptions) {
        if (!(parameters.key || parameters.property))
            throw "Parameters: 'data' and 'property' are required!";

        const request = this.factory.getProperty({
            urlOptions: this.urlOptions,
            key: parameters.key,
            property: parameters.property,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a GET request to get the related property value of a single item.
    */
    getRelated(parameters: PropertyRequestOptions) {
        if (!(parameters.key || parameters.property))
            throw "Parameters: 'data' and 'property' are required!";

        const request = this.factory.getRelated({
            urlOptions: this.urlOptions,
            key: parameters.key,
            property: parameters.property,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a GET request to retrieve the related property value of a single item by the id of the related item.
    */
    getRelatedById(parameters: SingleRelatedItemRequestOptions) {
        if (!(parameters.key || parameters.property || parameters.relatedId))
            throw "Parameters: 'data', 'relatedId' and 'property' are required!";

        const request = this.factory.getRelatedById({
            urlOptions: this.urlOptions,
            key: parameters.key,
            relatedId: parameters.relatedId,
            property: parameters.property,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a DELETE request to retrieve the delete all of the associated members in the relation property.
    */
    destroyRelated(parameters: PropertyRequestOptions) {
        if (!(parameters.key || parameters.property))
            throw "Parameters: 'data' and 'property' are required!";

        const request = this.factory.destroyRelated({
            urlOptions: this.urlOptions,
            key: parameters.key,
            property: parameters.property,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a DELETE request to retrieve the a single entry of the associated members in the relation property.
    */
    destroyRelatedById(parameters: SingleRelatedItemRequestOptions) {
        if (!(parameters.key || parameters.property || parameters.relatedId))
            throw "Parameters: 'data', 'relatedId' and 'property' are required!";

        const request = this.factory.destroyRelatedById({
            urlOptions: this.urlOptions,
            key: parameters.key,
            relatedId: parameters.relatedId,
            property: parameters.property,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a POST request to add a related item to the property collection.
    */
    createRelated(parameters: CreateRelatedRequestOptions) {
        if (!(parameters.key || parameters.property || parameters.link))
            throw "Parameters: 'data', 'link' and 'property' are required!";

        const data = {
            "@odata.id": parameters.link
        };

        const request = this.factory.createRelated({
            urlOptions: this.urlOptions,
            key: parameters.key,
            property: parameters.property,
            data: data,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        });

        request.execute();
    }

    /**
    * Executes a POST request to upload a media item.
    * @example
    *
    * const data = sf.data({
    *     entitySet: "images"
    * });
    * data.upload({
    *     data: {
    *         content: "base 64 representation of the file",
    *         contentType: "image/jpeg",
    *         name: "test.jpg",
    *         payload: {
    *             Title: "Test",
    *             entitySet: "test"
    *         },
    *         uploadProperties: {
    *             ParentId: "4BA7AD46-F29B-4E65-BE17-9BF7CE5BA1FB"
    *         }
    *     },
    *     successCb: successCb,
    *     failureCb: failureCb
    * });
    */
    upload(parameters: UploadRequestOptions) {
        if (!(parameters || parameters.data || parameters.data.content || parameters.data.contentType || parameters.data || parameters.data.name || parameters.data.uploadProperties))
            throw "parameters: content, contentType, name and uploadProperties are required!";

        const options = {
            urlOptions: this.urlOptions,
            _factory: this.factory,
            successCb: parameters.successCb,
            failureCb: parameters.failureCb
        };

        const batch = this.factory.batch(options);
        const transaction = batch.beginTransaction();

        const uploadedFile = transaction.upload({
            entitySet: this.urlOptions.entitySet,
            data: parameters.data.content,
            contentType: parameters.data.contentType,
            fileName: parameters.data.name,
            uploadProperties: parameters.data.uploadProperties
        });

        if (parameters.data.payload)
            transaction.update({
                entitySet: this.urlOptions.entitySet,
                key: uploadedFile,
                data: parameters.data.payload
            });

        if (parameters.publish === true) {
            transaction.operation({
                entitySet: this.urlOptions.entitySet,
                key: uploadedFile,
                data: {
                    action: "Publish"
                }
            });
        }

        batch.endTransaction(transaction);
        return batch.execute();
    }
}

export interface RequestOptionsBase {
    query?: Query;
    action?: string;
    successCb?: Function;
    failureCb?: Function;
    progressCb?: Function;
    fallbackProperties?: string[];
    key?: string | number;
}

export interface OperationsRequestOptions extends RequestOptionsBase {
    parentId?: string;
}

export interface CreateRequestOptions extends RequestOptionsBase {
    data?: object;
}

export interface UpdateRequestOptions extends CreateRequestOptions {
    saveTemp?: boolean;
}

export interface PropertyRequestOptions extends RequestOptionsBase {
    property: string;
}

export interface SingleRelatedItemRequestOptions extends PropertyRequestOptions {
    relatedId: string;
}

export interface CreateRelatedRequestOptions extends PropertyRequestOptions {
    link: string | number;
}

export interface UploadRequestOptions extends CreateRequestOptions {
    data: {
        content: string;
        contentType: string;
        uploadProperties: { [key: string]: string };
        name: string;
        payload: object;
    },
    publish: boolean;
}