import { ICommonRepository } from "../interfaces/ICommonRepository";
import IJitzSPContext from "../interfaces/IJitzSPContext";
import { IEmail } from "../interfaces/IModels";

export default class CommonRepository implements ICommonRepository {
  public context: IJitzSPContext;

  constructor(context: IJitzSPContext) {
    this.context = context;
  }

  public sendEmail(email: IEmail): Promise<boolean> {
    email.properties.__metadata = {
      type: "SP.Utilities.EmailProperties",
    };
    // console.log(JSON.stringify(email.properties));
    var requestUrl = `${this.context.siteUrl}/_api/SP.Utilities.Utility.SendEmail`;
    return this.context.client
      .post(requestUrl, email, {
        Accept: "application/json;odata=nometadata",
        "Content-type": "application/json;odata=verbose",
        "odata-version": "",
      })
      .then((response: any): Promise<boolean> => {
        if (response.status >= 200 && response.status < 300) {
          var json = response;
          return json;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      });
  }

  public getData(
    listName: string,
    selectFields?: string,
    expand?: string,
    filters?: string,
    orderBy?: string,
    top?: number,
    skipTokenUniqueField?: string,
    skipTokenUniqueFieldValue?: string
  ): Promise<any> {
    let queryUrlGetAllItems: string =
      `/_api/web/lists/GetByTitle('` + listName + `')/items`;

    if (selectFields != null && selectFields != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=` + selectFields;
    } else {
      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=*`;
    }
    if (expand != null && expand != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$expand=` + expand;
    }
    if (top != null && top != undefined && top > 0) {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$top=` + top;
    }
    if (filters != null && filters != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$filter=` + filters;
    }
    if (orderBy != null && orderBy != "") {
      queryUrlGetAllItems = queryUrlGetAllItems + `&$orderby=` + orderBy;
    }
    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) => {
        return data;
      })
      .catch((ex: any) => {
        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
        throw ex;
      });
  }

  public get(url: string): Promise<any> {
    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) => {
        return data;
      })
      .catch((ex: any) => {
        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
        throw ex;
      });
  }

  public post(url: string, data: any, header?: any): Promise<any> {
    return this.context.client
      .post(url, data, header)
      .then((response: any) => {
        if (response.status >= 200 && response.status < 300) {
          return response.data;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      })
      .then((data: any) => {
        return data;
      })
      .catch((ex: any) => {
        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
        throw ex;
      });
  }

  public getFiles(
    libraryName: string,
    selectFields: string,
    filter: string,
    expandFields: string
  ): Promise<any> {
    let url: string = `/_api/web/lists/getbytitle('${libraryName}')/Items?$select=*,File/Name,File/ServerRelativeUrl`;
    if (selectFields != undefined && selectFields.length > 0) {
      url = `${url},${selectFields}`;
    }
    if (filter != undefined && filter.length > 0) {
      url = `${url}&$filter=${filter}`;
    }
    url = `${url}&$expand=File`;
    if (expandFields != undefined && expandFields.length > 0) {
      url = `${url},${expandFields}`;
    }
    return this.context.client.get(url).then((response: any) => {
      if (response.status >= 200 && response.status <= 300) {
        var json = response.data.d.results;
        return json;
      } else {
        return Promise.reject(new Error(JSON.stringify(response)));
      }
    });
  }

  public uploadFile(
    libraryName: string,
    fileName: string,
    arrayBuffer: ArrayBuffer
  ): Promise<any> {
    return this.context.client
      .postWithOutStringify(
        `/_api/Web/Lists/getByTitle('${libraryName}')/RootFolder/Files/Add(url='${fileName}', overwrite=true)`,
        arrayBuffer,
        {
          Accept: "application/json;odata=verbose",
          "content-length": arrayBuffer.byteLength.toString(),
        }
      )
      .then((response: any) => {
        if (response.status >= 200 && response.status <= 300) {
          var json = response.data.d;
          return json;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      });
  }

  public getFileItem(libraryName: string, fileUrl: string): Promise<any> {
    // `${this._webAbsoluteUrl}/_api/web/GetFileByServerRelativeUrl('${fileUrl}')/$value`
    return this.context.client
      .get(
        `/_api/web/lists/getbytitle('${libraryName}')/Items?$filter=FileLeafRef eq '${fileUrl}'&$select=Id`
      )
      .then((response: any) => {
        if (response.status >= 200 && response.status <= 300) {
          var json = response.data.d;
          return json;
        } else {
          return Promise.reject(new Error(JSON.stringify(response)));
        }
      });
  }

  public async updateMetadata(listName: string, item: any): Promise<any> {
    await this.getEntityType(listName).then((entityType) => {
      item.__metadata = {
        //etag: "1",
        type: entityType,
      };
      var requestUrl = `_api/web/lists/getbytitle('${listName}')/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)));
          }
        });
    });

    let url: string = `/_api/web/lists/getbytitle('${listName}')/items(${item.Id})?$select=*,File/Name,File/ServerRelativeUrl&$expand=File`;
    return this.context.client.get(url).then((response: any) => {
      if (response.status >= 200 && response.status <= 300) {
        var json = response.data.d;
        return json;
      } else {
        return Promise.reject(new Error(JSON.stringify(response)));
      }
    });
  }

  public deleteFile(listName: string, id: number): Promise<boolean> {
    var requestUrl = `_api/web/lists/getbytitle('${listName}')/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)));
        }
      });
  }

  private getEntityType(listName: string): Promise<string> {
    return new Promise<string>(
      (
        resolve: (listItemEntityTypeName: string) => void,
        reject: (error: any) => void
      ): void => {
        this.context.client
          .get(
            `_api/web/lists/getbytitle('${listName}')?$select=ListItemEntityTypeFullName`
          )
          .then(
            (
              response: any
            ): Promise<{ ListItemEntityTypeFullName: string }> => {
              return response;
            },
            (error: any): void => {
              reject(error);
            }
          )
          .then((response: any): void => {
            var _listEntityType = response.data.d.ListItemEntityTypeFullName;
            resolve(_listEntityType || "");
          });
      }
    );
  }
}