import { BasicDataSource } from './BasicDataSource';

/**
 * 实现/BasicDataSource抽象类，用于懒数据加载
 */
export class LazyDataSource<T> extends BasicDataSource<T> {
  // private dataArray: Array<T> = new Array();
  // private dataArray: Array<string> = new Array("0", "1", "2");
  // private dataArray: string[] = ["0", "1", "2"];
  private dataArray: T[] = [];

  constructor() {
    super();
    // for (let i = 0; i < 100; i++) {
    //   this.dataArray.push(i)
    // }
  }

  // 获取数据总个数
  public totalCount(): number {
    return this.dataArray.length;
  }

  // 获取索引对应的Item数据
  public getData(index: number): T {
    return this.dataArray[index];
  }

  // 获取索引对应的Item数据
  public get(index: number): T {
    return this.getData(index);
  }

  public getFirst(): T {
    return this.getData(0);
  }

  public getLast(): T {
    return this.getData(this.totalCount() - 1);
  }

  public size(): number {
    return this.dataArray.length
  }

  // 获取所有数据
  public getDataArray(): T[] {
    return this.dataArray;
  }

  // 增加/插入1个Item/数据,若index为undefined,则在数据尾部增加1个元素;否则,在指定索引(可为负/或大于数组长度)位置插入1个元素
  public addItem(item: T, startPosition?: number): void {
    if (startPosition == undefined) {
      // 将新元素添加到数组的末尾
      this.dataArray.push(item);
      // this.dataArray.splice(this.dataArray.length, 0, item)
      this.notifyDataAdd(this.dataArray.length - 1);
    } else {
      // 从数组中的index位置开始删除0个元素，并在同一位置插入((1个或多个))新元素，返回已删除的元素。
      // 当index大于等于数组长度时，不删除任何数据，且item加在数组末尾
      // 当index为负数时，其代表从数组后向前的索引位置
      this.dataArray.splice(startPosition, 0, item);
      this.notifyDataAdd(startPosition);
    }
  }

  public addItems(arr: T[], startPosition?: number): void {
    if (startPosition == undefined) {
      // 将新元素添加到数组的末尾
      this.dataArray.push(...arr)
      for (let index = this.dataArray.length - arr.length; index < this.dataArray.length; index++) {
        this.notifyDataAdd(index);
      }
    } else {
      // 从数组中的position位置开始删除0个元素，并在同一位置插入((1个或多个))新元素，返回已删除的元素。
      // 当index大于等于数组长度时，不删除任何数据，且arr加在数组末尾
      // 当index为负数时，其代表从数组后向前的索引位置
      this.dataArray.splice(startPosition, 0, ...arr);
      for (let index = startPosition; index < arr.length; index++) {
        this.notifyDataAdd(index);
      }
    }
  }

  // 在数据尾部增加1到多个元素
  public push(...items: T[]): void {
    this.dataArray.push(...items)
    for (let index = this.dataArray.length - items.length; index < this.dataArray.length; index++) {
      this.notifyDataAdd(index);
    }
  }



  // 在数据尾部增加一个同类型的LazyDataSource
  public pushDataSource(dataSource: LazyDataSource<T>): void {
    this.push(...dataSource.dataArray)
  }

  // 在数据尾部增加1个元素
  public addLastItem(item: T): void {
    this.addItem(item)
  }

  // 在数据开头插入1个元素
  public addFirstItem(item: T): void {
    // 在数组的开头插入(1个或多个)新元素
    // this.dataArray.unshift(item)
    // this.notifyDataAdd(0);
    this.addItem(item, 0)
  }

  // 在第2个元素位置,插入1个元素
  public add2ndItem(item: T): void {
    this.addItem(item, 1)
  }

  // 在第3个元素位置,插入1个元素
  public add3rdItem(item: T): void {
    this.addItem(item, 2)
  }

  // 在第4个元素位置,插入1个元素
  public add4thItem(item: T): void {
    this.addItem(item, 3)
  }


  // 把from位置的item移动到to位置(暂不支持from/to为负数或大于等于数组长度)
  public moveItem(from: number, to: number): void {
    // 当from/to大于/等于数组长度时;
    if (from >= this.dataArray.length) {
      from = this.dataArray.length - 1;
    }
    if (to >= this.dataArray.length) {
      to = this.dataArray.length - 1;
    }
    // 当from/to为负时;
    let remainderFrom = from % this.dataArray.length
    if (remainderFrom < 0) {
      from = remainderFrom + this.dataArray.length
    }
    let remainderTo = to % this.dataArray.length
    if (remainderTo < 0) {
      to = remainderTo + this.dataArray.length
    }

    // 1.把from位置元素提出暂存
    let tempFrom: T = this.dataArray[from];
    // 2.把to位置元素覆盖from位置元素,
    let tempTo: T = this.dataArray[to];
    this.updateItem(tempTo, from)
    // 3.把暂存的from位置元素覆盖to位置元素
    this.updateItem(tempFrom, to)
    this.notifyDataMove(from, to);
  }

  // 删除index指定索引位置的元素
  public deleteItem(index?: number): void {
    if (index == undefined) {
      // 删除数组的最后1个元素(倒数第1个元素)
      // this.dataArray.pop()
      this.dataArray.splice(-1, 1)
      this.notifyDataDelete(this.dataArray.length);
    } else {
      // 从数组中的index位置开始,删除1个元素
      // 当index大于等于数组长度时,不删除任何数据
      // 当index为负数时，其代表从数组后向前的索引位置
      this.dataArray.splice(index, 1);
      this.notifyDataDelete(index);
    }
  }

  // 删除index指定索引位置的元素
  public deleteItems(startIndex: number, count?: number): void {
    if (startIndex < 0) {
      return
    }
    this.dataArray.splice(startIndex, count || (this.dataArray.length - startIndex));
    let to = 0
    if (count == undefined) {
      to = this.dataArray.length - 1
    } else {
      to = count + startIndex
      if (to >= this.dataArray.length) {
        to = this.dataArray.length - 1;
      }
    }
    this.notifyDataMove(startIndex, to);
  }

  // 删除最后1个元素
  public pop(): void {
    this.deleteItem()
  }

  // 删除最后1个元素
  public deleteLastItem(): void {
    this.deleteItem()
  }

  // 删除第1个元素
  public deleteFirstItem(): void {
    this.deleteItem(0)
  }

  // 删除第1个元素
  public delete1stItem(): void {
    this.deleteItem(0)
  }

  // 删除第2个元素
  public delete2ndItem(): void {
    this.deleteItem(1)
  }

  // 删除第3个元素
  public delete3rdItem(): void {
    this.deleteItem(2)
  }

  // 删除第4个元素
  public delete4thItem(): void {
    this.deleteItem(3)
  }

  // 修改/更新index指定索引位置的元素
  public updateItem(item: T, index?: number): void {
    if (index == undefined || index >= this.dataArray.length) {
      // 当不传index或index大于等于数组长度时，修改/更新数组的最后1个元素
      this.dataArray.splice(this.dataArray.length - 1, 1, item);
      this.notifyDataChange(this.dataArray.length);
    } else {
      // 从数组中的index位置开始,删除1个元素
      // 当index为负数时，其代表从数组后向前的索引位置
      this.dataArray.splice(index, 1, item);
      this.notifyDataChange(index);
    }
  }

  // 修改/更新最后1个元素
  public updateLastItem(item: T): void {
    this.updateItem(item)
  }

  // 修改/更新第1个元素
  public updateFirstItem(item: T): void {
    this.updateItem(item, 0)
  }

  // 修改/更新第1个元素
  public update2ndItem(item: T): void {
    this.updateItem(item, 0)
  }

  // 修改/更新第2个元素
  public update1stItem(item: T): void {
    this.updateItem(item, 1)
  }

  // 修改/更新第3个元素
  public update3rdItem(item: T): void {
    this.updateItem(item, 2)
  }

  // 修改/更新第4个元素
  public update4thItem(item: T): void {
    this.updateItem(item, 3)
  }

  // 清空数组
  public clear(): void {
    this.replaceAll()
  }


  // 把数据全部删除，再添加全部新元素
  public replaceAll(...items: T[]): void {
    // 从数组中的0位置开始删除dataArray.length个元素，并在同一位置插入((1个或多个))新元素，返回已删除的元素。
    this.dataArray.splice(0, this.dataArray.length, ...items);
    this.notifyDataReload()
  }



  // 获取指定元素的下标
  public getIndexOf(element: T): number {
    for (let index = 0; index < this.dataArray.length; index++) {
      if (this.dataArray[index] == element) {
        return index
      }
    }
    return -1
  }

  public isEmpty(): boolean {
    return this.dataArray.length == 0
  }

  public isNotEmpty(): boolean {
    return this.dataArray.length > 0
  }

  public sort(comparator: (firstValue: T, secondValue: T) => number): void {
    this.dataArray.sort(comparator)
  }

  public updateItems(start: number, data: T[]): void {
    // 从数组中的start位置开始删除dataArray.length个元素，并在同一位置插入((1个或多个))新元素。
    this.dataArray.splice(start, this.dataArray.length, ...data);
    this.notifyDataReload()
  }

  public reloadData(): void {
    this.notifyDataReload();
  }
  //**********************//////////


  public clearAllData(){

    this.dataArray = []
    this.notifyDataReload();
  }

}