import UtilityService from "../../services/UtilityService";
import IJitzSPContext from "../interfaces/IJitzSPContext";
import { IListItemsMetadata, IModel } from "../interfaces/IModels";
import { IRepository } from "../interfaces/IRepository";

export default class Repository<T extends IModel> implements IRepository<T> {
  private _listEntityType?: string;
  public context: IJitzSPContext;
  public listName: string;
  public listGuid: string;
  public listUrl: string;

  constructor(
    context: IJitzSPContext,
    listName: string,
    listGuid: string = ""
  ) {
    this.context = context;
    this.listName = listName;
    this.listGuid = listGuid;
    this.listUrl = `${this.context.siteUrl}/_api/web/lists${
      this.listGuid == ""
        ? "/GetByTitle('" + this.listName + "')"
        : "(guid'" + this.listGuid + "')"
    }`;
  }

  public getAll(
    selectFields?: string,
    expand?: string,
    filters?: string,
    orderBy?: string,
    top?: number,
    skip?: number,
    skipTokenUniqueField?: string,
    skipTokenUniqueFieldValue?: string
  ): Promise<T[]> {
    let queryUrlGetAllItems: string = `${this.listUrl}/items`;

    if (selectFields != null && selectFields != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=` + selectFields;
    } else {
      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=*`;
    }
    if (orderBy != null && orderBy != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$orderby=` + orderBy;
    }
    if (skip != null && skip != undefined && skip > 0) {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$skip=` + skip;
    }
    if (top != null && top != undefined && top > 0) {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$top=` + top;
    }
    if (expand != null && expand != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$expand=` + expand;
    }
    if (filters != null && filters != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$filter=` + filters;
    }
    if (
      skipTokenUniqueField != null &&
      skipTokenUniqueField != undefined &&
      skipTokenUniqueFieldValue != null &&
      skipTokenUniqueFieldValue != undefined
    ) {
      if (skipTokenUniqueField == "Id" || skipTokenUniqueField == "id") {
        skipTokenUniqueField = "ID";
      }
      queryUrlGetAllItems =
        queryUrlGetAllItems +
        `&$skiptoken=Paged=TRUE%26p_${skipTokenUniqueField}=${skipTokenUniqueFieldValue}`;
    }

    return this.context.client
      .get(queryUrlGetAllItems)
      .then((response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return response.data.d;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      })
      .then((data: any) => {
        // let items: T[] = [];
        // if (data) {
        //   for (let i = 0; i < data.length; i++) {
        //     let item = data[i];
        //     items.push(item);
        //   }
        // }
        return data;
      })
      .catch((ex: any) => {
        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
        throw ex;
      });
  }

  public getAllFromUrl(url: string): Promise<T[]> {
    return this.context.client
      .get(url)
      .then((response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return response.data.d;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      })
      .then((data: any) => {
        // let items: T[] = [];
        // if (data) {
        //   for (let i = 0; i < data.length; i++) {
        //     let item = data[i];
        //     items.push(item);
        //   }
        // }
        return data;
      })
      .catch((ex: any) => {
        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
        throw ex;
      });
  }

  public async getAllRecursive(
    selectFields?: string,
    expand?: string,
    filters?: string,
    orderBy?: string,
    top?: number,
    maxRecursiveCount = 5
  ): Promise<T[]> {
    let items: T[] = [];
    let queryUrlGetAllItems: string = `${this.listUrl}/items`;

    if (selectFields != null && selectFields != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=` + selectFields;
    } else {
      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=*`;
    }
    if (expand != null && expand != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$expand=` + expand;
    }
    if (filters != null && filters != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$filter=` + filters;
    }
    if (orderBy != null && orderBy != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$orderby=` + orderBy;
    }
    if (top != null && top != undefined && top > 0) {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$top=` + top;
    }

    await this.context.client
      .get(queryUrlGetAllItems)
      .then(async (response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return await response.data.d;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      })
      .then(async (data: any) => {
        if (data.results) {
          for (let i = 0; i < data.results.length; i++) {
            let item = data.results[i];
            items.push(item);
          }
        }
        let returnItem: IListItemsMetadata<T> = {
          __next: data.__next,
          results: items,
        };
        if (returnItem.__next != undefined && returnItem.__next.length > 0) {
          items = await this.recursiveFetch(
            returnItem.__next,
            2,
            maxRecursiveCount,
            returnItem.results
          );
        }
      })
      .catch((ex: any) => {
        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
        throw ex;
      });
    return items;
  }

  private async recursiveFetch(
    url: string,
    recursiveCount: number = 1,
    maxRecursiveCount: number = 5,
    items: T[] = []
  ): Promise<T[]> {
    items = items || [];
    await this.context.client
      .get(url)
      .then(async (response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return await response.data.d;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      })
      .then(async (data: any) => {
        if (data.results) {
          for (let i = 0; i < data.results.length; i++) {
            let item = data.results[i];
            items.push(item);
          }
        }
        let returnItem: IListItemsMetadata<T> = {
          __next: data.__next,
          results: items,
        };

        if (
          returnItem.__next != undefined &&
          returnItem.__next.length > 0 &&
          recursiveCount < maxRecursiveCount
        ) {
          items = await this.recursiveFetch(
            returnItem.__next,
            recursiveCount + 1,
            maxRecursiveCount,
            returnItem.results
          );
        }
      })
      .catch((ex: any) => {
        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
        // throw ex; //Let it continue
      });
    return items;
  }

  public itemsCount(filters?: string) {
    let queryUrlGetAllItems: string = `${this.listUrl}/ItemCount`;

    if (filters != null && filters != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `?$filter=` + filters;
    }

    return this.context.client
      .get(queryUrlGetAllItems)
      .then((response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return response.data.d.ItemCount;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      })
      .then((data: any) => {
        return data;
      })
      .catch((ex: any) => {
        console.log("loadEvents > JitzSPHttpClient.get()...catch:", ex);
        throw ex;
      });
  }

  public async getItemById(
    id: number,
    selectFields?: string,
    expand?: string
  ): Promise<T> {
    const queryUrl: string =
      `${this.listUrl}/items(` +
      id +
      `)` +
      `?$select=*${selectFields != undefined ? `,${selectFields}` : ""}` +
      `${expand != undefined ? `&$expand=${expand}` : ``}`;

    return await this.context.client
      .get(queryUrl)
      .then((response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return response.data.d;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      })
      .then((data: any) => {
        return data;
      })
      .catch((ex: any) => {
        console.log("loadEvents > JitzSPHttpClient.get()...catch:", ex);
        throw ex;
      });
  }

  public createItem(item: T): Promise<T> {
    return this.getEntityType().then((entityType) => {
      item.__metadata = {
        type: entityType,
      };
      var requestUrl = `${this.listUrl}/items`;
      return this.context.client
        .post(requestUrl, item, {
          Accept: "application/json;odata=nometadata",
          "Content-type": "application/json;odata=verbose",
          "odata-version": "",
        })
        .then((response: any): Promise<T> => {
          if (response.status >= 200 && response.status < 300) {
            var json = response;
            return json;
          } else {
            return Promise.reject(new Error(JSON.stringify(response)));
          }
        });
    });
  }

  public updateItem(item: T): Promise<T> {
    return this.getEntityType().then((entityType) => {
      item.__metadata = {
        //etag: "1",
        type: entityType,
      };
      var requestUrl = `${this.listUrl}/items(${item.Id})`;
      return this.context.client
        .post(requestUrl, item, {
          Accept: "application/json;odata=nometadata",
          "Content-type": "application/json;odata=verbose",
          "odata-version": "",
          "IF-MATCH": "*",
          "X-HTTP-Method": "MERGE",
        })
        .then((response: any) => {
          if (response.status >= 200 && response.status < 300) {
            return item;
          } else {
            // console.log(JSON.stringify(response));
            return Promise.reject(new Error(JSON.stringify(response)));
          }
        });
    });
  }

  public deleteItem(id: number): Promise<boolean> {
    var requestUrl = `${this.listUrl}/items(${id})`;
    return this.context.client
      .post(
        requestUrl,
        {},
        {
          Accept: "application/json;odata=nometadata",
          "Content-type": "application/json;odata=verbose",
          "odata-version": "",
          "IF-MATCH": "*",
          "X-HTTP-Method": "DELETE",
        }
      )
      .then((response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return true;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      });
  }

  public deleteItems(ids: number[]): Promise<boolean> {
    // Here we will delete two different list items from two different lists in a single REST call
    // Every batch will have a Batch ID/GUID
    var batchGuid = UtilityService.generateGUID();

    // Every delete/changeset should have a ChangeSet ID/GUID
    var changeSetGUID = UtilityService.generateGUID()();

    // creating the body
    var batchContents = new Array();

    ids.map((id) => {
      // Request creation for first list item Delete
      var endpoint = `${this.listUrl}/items(${id})`;

      // create the changeset
      batchContents.push("--changeset_" + changeSetGUID);
      batchContents.push("Content-Type: application/http");
      batchContents.push("Content-Transfer-Encoding: binary");
      batchContents.push("");
      batchContents.push("DELETE " + endpoint + " HTTP/1.1");
      batchContents.push("Content-Type: application/json;odata=verbose");
      batchContents.push("Accept: application/json;odata=verbose");
      batchContents.push("IF-MATCH: *");
      batchContents.push("");
    });

    batchContents.push("--changeset_" + changeSetGUID + "--");

    // batch body
    var batchBody = batchContents.join("\r\n");

    batchContents = new Array();

    // create a batch for creating items
    batchContents.push("--batch_" + batchGuid);
    batchContents.push(
      'Content-Type: multipart/mixed; boundary="changeset_' +
        changeSetGUID +
        '"'
    );
    batchContents.push("Content-Length: " + batchBody.length);
    batchContents.push("Content-Transfer-Encoding: binary");
    batchContents.push("");
    batchContents.push(batchBody);
    batchContents.push("");

    batchContents.push("--batch_" + batchGuid + "--");
    batchBody = batchContents.join("\r\n");

    // create the request endpoint
    var batchEndPoint = `${this.context.siteUrl}/_api/$batch`;

    // // create request
    // jQuery.ajax({
    //     url: endpoint,
    //     type: 'POST',
    //     headers: batchRequestHeader,
    //     data: batchBody,
    //     success: function (response) {
    //         console.log(response);
    //     },
    //     fail: function (error) {
    //         console.log(response);
    //     }
    // });

    return this.context.client
      .post(batchEndPoint, batchBody, {
        "Content-Type": 'multipart/mixed; boundary="batch_' + batchGuid + '"',
      })
      .then((response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return true;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      });
  }

  private getEntityType(): Promise<string> {
    return new Promise<string>(
      (
        resolve: (listItemEntityTypeName: string) => void,
        reject: (error: any) => void
      ): void => {
        if (this._listEntityType) {
          resolve(this._listEntityType);
          return;
        }

        this.context.client
          .get(`${this.listUrl}?$select=ListItemEntityTypeFullName`)
          .then(
            (
              response: any
            ): Promise<{ ListItemEntityTypeFullName: string }> => {
              return response;
            },
            (error: any): void => {
              reject(error);
            }
          )
          .then((response: any): void => {
            this._listEntityType = response.data.d.ListItemEntityTypeFullName;
            resolve(this._listEntityType || "");
          });
      }
    );
  }
}