import { SortDirection } from "@angular/material/sort";

export interface ResponseDto {
  data: any,
  error: number
}

export interface ListResponseDto {
  data: {
    sum: number,
    list: any[]
  },
  error: number
}

export interface LangString {
  en: string,
  fa: string
}

export class Entity {
  absorb(data: any) {
    if(typeof data == 'number' || typeof data == 'string') {
      (this as any).id = data;
      return;
    }
    for(let key in data) (this as any)[key] = data[key];
  }

  get trans(): any {
    let o = {...this};
    delete o.meta;
    return o;
  }

  meta: any = {};
}

export class Batch<T extends Entity> {
  limit: number = 0;
  sum: number = 0;
  totalPages: number = 0;
  offset: number = 0;
  filter: string = '';
  constraints: any = {};
  meta: any = {};
  sort: string = "StartCreationDateRange";
  order: SortDirection = 'asc'
  list: T[] = [];
  private _page: number = 0;

  set page(v: number) {
    this._page = v;
    this.offset = this.limit*this._page;
  }

  get page(): number {
    return this._page;
  }

  constructor(/*private type: { new(data?: any): T ;}, */offset?: number, limit?: number) {
    this.limit = limit || this.limit;
    this.offset = offset || this.offset;
  }

  remove(m: T) {
    this.list = this.list.filter(el => (el as any).id!=(m as any).id)
  }

  /*absorb(batchData: any) {
    this.sum = batchData.sum;
    this.totalPages = Math.ceil(batchData.sum/this.limit);
    this.list = [...this.list, ...batchData.list.map((item: any) => new this.type(item))];
  }*/
}

export class Section extends Entity {
  constructor(data?: any) {
    super();
    if(data) this.absorb(data);
  }

  override absorb(data: any) {
    super.absorb(data);
    if(data.children)
      this.children = data.children.map((record: any) => new Section(record));
  }

  id: number = 0;
  start: number = 0;
  end: number = 0;
  title: LangString = {en: '', fa: ''};
  children: Section[] = [];
}

export class Verse extends Entity {
  constructor(data?: any) {
    super();
    if(data) this.absorb(data);
  }

  override absorb(data: any) {
    super.absorb(data);
    if(data.verseKeywords)
      this.verseKeywords = data.verseKeywords.map((record: any) => new VerseKeyword(record));
    if(data.versePersons)
      this.versePersons = data.versePersons.map((record: any) => new VersePerson(record));
    if(data.triplets)
      this.triplets = data.triplets.map((record: any) => new Triplet(record));
    if(data.prevs)
      this.prevs = data.prevs.map((record: any) => new Verse(record));
    if(data.nexts)
      this.nexts = data.nexts.map((record: any) => new Verse(record));
  }

  get mesras(): string[] {
    return this.content.split(/ *\/ */);
  }

  id: number = 0;
  content: string = '';
  verseKeywords: VerseKeyword[] = [];
  versePersons: VersePerson[] = [];
  triplets: Triplet[] = [];
  prevs: Verse[] = [];
  nexts: Verse[] = [];
}

export class VerseKeyword extends Entity {
  constructor(data?: any) {
    super();
    if(data) this.absorb(data);
  }

  override absorb(data: any) {
    super.absorb(data);
    this.meta.state =
    this.state = data.state || '';
    if(data.keyword)
      this.keyword = new Keyword(data.keyword);
  }

  id: number = 0;
  state: string = '';
  keyword: Keyword = new Keyword();
}

export class Keyword extends Entity {
  constructor(data?: any) {
    super();
    if(data) this.absorb(data);
  }

  override absorb(data: any) {
    super.absorb(data);
    this.desc.fa = data.descFa || '';
    this.desc.en = data.descEn || '';
  }

  id: number = 0;
  word: string = '';
  cat: string = '';
  transliteration: string = '';
  desc: LangString = {en: '', fa: ''};
}

export class VersePerson extends Entity {
  constructor(data?: any) {
    super();
    if(data) this.absorb(data);
  }

  override absorb(data: any) {
    super.absorb(data);
    this.state = data.state || '';
    if(data.person)
      this.person = new Person(data.person);
  }

  id: number = 0;
  state: string = '';
  person: Person = new Person();
}

export class Person extends Entity implements d3.SimulationNodeDatum {
  constructor(data?: any) {
    super();
    if(data) this.absorb(data);
  }

  override absorb(data: any) {
    super.absorb(data);
    if(data.alts)
      this.alts = data.alts.split('|');
    this.radius = 1.5*Math.log(this.verseCount + 15);
  }

  id: number = 0;
  name: string = '';
  alts: string[] = [];
  cats: number[] = [];
  transliteration: string = '';
  verseCount: number = 0;
  radius: number = 5;
  x: number = 0;
  y: number = 0;
  fx: number|null = null;
  fy: number|null = null;
}

export class Predicate extends Entity {
  constructor(data?: any) {
    super();
    if(data) this.absorb(data);
  }

  id: number = 0;
  label: LangString = {en: '', fa: ''};
}

export class Triplet extends Entity implements d3.SimulationLinkDatum<Person> {

  constructor(data?: any) {
    super();
    if(data) this.absorb(data);
  }

  override absorb(data: any) {
    super.absorb(data);
    if(data.predicateId)
      this.predicateIds = [data.predicateId];
    if(data.subject && !(data.subject instanceof Person))
      this.subject = this.source = new Person(data.subject);
    if(data.predicate && !(data.predicate instanceof Predicate))
      this.predicate = new Predicate(data.predicate);
    if(data.object && !(data.object instanceof Person))
      this.object = this.target = new Person(data.object);
    if(data.verse && !(data.verse instanceof Verse))
      this.verse = new Verse(data.verse);
  }

  override get trans() {
    return {
      id: this.id,
      subjectId: this.subject.id || this.subjectId,
      predicateId: this.predicate.id || this.predicate,
      objectId: this.object.id || this.objectId,
      verseId: this.verse.id || this.verseId,
    }
  }

  id: number = 0;
  subject: Person = new Person();
  predicate: Predicate = new Predicate();
  object: Person = new Person();
  verse: Verse = new Verse();

  source: Person = new Person();
  predicates: Predicate[] = [];
  target: Person = new Person();

  predicateIds: number[] = [];
  predicateId: number = 0;
  subjectId: number = 0;
  objectId: number = 0;
  verseId: number = 0;
}