document.ts

import { throws } from 'assert';
import { AngularFirestore, AngularFirestoreCollection } from '@angular/fire/firestore';
import { Observable, forkJoin } from 'rxjs';

import { AppInjector } from './app-injector';
import { FireStoreDocument } from './firestoreDocument';
import Query from './query';
import * as firebase from 'firebase';

export default class DocumentNotFoundError extends Error {}

export function Collection(nome) {
  return function (target) {
    target.__name = nome;
    // target["__name"] = nome;
    Object.assign(target, {
      __name: nome,
    });
  };
}

/**
 * Formato: name e type
 * @param data
 */
export function oneToOne(data) {
  function actualDecorator(target, property: string | symbol): void {
    if (target.__oneToOne == undefined) {
      Object.defineProperty(target, '__oneToOne', {
        value: [],
        writable: true,
        enumerable: true,
      });
    }

    target.__oneToOne.push({ property: property, foreignKeyName: data.name, type: data.type });
  }

  // return the decorator
  return actualDecorator;
}

export function ignore() {
  function actualDecorator(target, property: string | symbol): void {
    if (target.__ignore == undefined) {
      Object.defineProperty(target, '__ignore', {
        value: [],
        writable: true,
        enumerable: true,
      });
    }

    target.__ignore.push(property);
  }

  // return the decorator
  return actualDecorator;
}

export function date() {
  function actualDecorator(target, property: string | symbol): void {
    if (target.__ignore == undefined) {
      Object.defineProperty(target, '__date', {
        value: [],
        writable: true,
        enumerable: true,
      });
    }
    target.property = '';
    target.__date.push(property);
  }

  // return the decorator
  return actualDecorator;
}

/*
export function lazy() {

    function actualDecorator(target, property: string | symbol): void {
        if (target.__ignore == undefined)
                Object.defineProperty(target, '__lazy', {
                    value: [],
                    writable: true,
                    enumerable: true
                })
            target.property = "";
            target.__lazy.push(property);

    }

    return actualDecorator;
}


 * This class is used to intercept a call to an attribute. When a property is marked as @lazy they will be retrivied from document only when needed.
 *
class ExtendableProxy {
    constructor() {
        return new Proxy(this, {
            get: function(obj, prop, receiver) {
                if( obj["__lazy"] != undefined && obj[prop] == undefined){
                    let isLazy = false;
                    obj["__lazy"].forEach(property=>{
                        if(prop == property)
                            isLazy = true;
                    })
                    let func = obj["getLazy"];
                    if(isLazy && typeof func !== "undefined"){
                        let r = null;
                        let o = null;
                        return new Observable(observer=>{
                            o = observer;
                            obj["getLazy"]().subscribe(resultado=>{
                                observer.next(resultado);
                                observer.complete();
                            }, err=>{
                                observer.error(err);
                            });
                        }).subscribe(res=>{
                            o.next(res);
                            o.complete();
                        })

                    }
                }

                return obj[prop];
            }
        });
    }
}*/

export class Document {
  constructor(protected id) {
    this.db = AppInjector.get(AngularFirestore);
    /*const settings = { experimentalForceLongPolling: true };
        this.db.firestore.app.firestore().settings( settings );*/

    this.constructDateObjects();
  }
  db: AngularFirestore;

  static getAngularFirestore() {
    return AppInjector.get(AngularFirestore);
  }

  static getDaysInterval = function (start, end): any[] {
    const datas = [];
    for (const dt = new Date(start); dt <= end; dt.setDate(dt.getDate() + 1)) {
      datas.push(new Date(dt));
    }
    return datas;
  };

  static filterDocumentsByDate(documents, dateField, start, end) {
    const filteredDocuments = [];
    if (Array.isArray(documents) && documents.length > 0) {
      const dateInterval = this.getDaysInterval(end, start);

      dateInterval.forEach((data) => {
        documents.forEach((document) => {
          const date = document[dateField].toDate();

          if (date.toDateString() === data.toDateString()) {
            filteredDocuments.push(document);
          }
        });
      });
    }

    return filteredDocuments;
  }

  static getByQuery(query, orderBy = null):Observable<any> {
    return new Observable((observer) => {
      this.getAll(query, orderBy).subscribe(
        (resultado) => {
          if (resultado.length > 0) {
            observer.next(resultado[0]);
            observer.complete();
          } else {
            observer.next(null);
            observer.complete();
          }
        },
        (err) => {
          observer.error(err);
        }
      );
    });
  }

  /**
   * Get a document from collection.
   * @param id
   * @returns Observable containing the document; or error if document does not exists.
   */
  static get(id):Observable<any> {
    if (id == null || id == undefined) {
      throw new Error('ID não posse ser vazio.');
    }

    const db = this.getAngularFirestore();

    Document.prerequisitos(this['__name'], db);

    return new Observable((observer) => {
      const n = this['__name'];
      const document: any = db.doc<any>(this['__name'] + '/' + id);

      document.get({ source: 'server' }).subscribe((result) => {
        try {
          observer.next(new FireStoreDocument(result).toObject(this['prototype']));
          observer.complete();
        } catch (e) {
          observer.error(
            new Error('Document not found. Collection: ' + this['__name'] + '. ID: ' + id)
          );
        } finally {
        }
      });
    });
  }

  static search(query:Query){
    return new Observable((observer) => {
      const db = this.getAngularFirestore();
      const objetos = [];
      const collection = db.collection(this['__name'], (ref) => ref.orderBy(query.column).startAt(query.value).endAt(query.value+"\uf8ff"));
      
     

      collection.get({ source: 'server' }).subscribe(
        (resultados) => {
          const i = 0;
          resultados.docs.forEach((document) => {
            objetos.push(new FireStoreDocument(document).toObject(this['prototype']));
          });
          observer.next(objetos);
          observer.complete();
        },
        (err) => {
          observer.error(err);
        }
      );
    });
  }

  static buildCollection(db, collectionName, query, orderByParam = null) {
    let collection: any = db.collection(collectionName);

    if (query != null) {
      // collection = db.collection(collectionName, ref=>ref.where(query.column, query.operator, query.value));
      if (orderByParam != null) {
        collection = db.collection(collectionName, (ref) =>
          Query.build(ref, query).orderBy(orderByParam)
        );
      } else {
        collection = db.collection(collectionName, (ref) => Query.build(ref, query));
      }
    } else if (orderByParam != null) {
      collection = db.collection(collectionName, (ref) => ref.orderBy(orderByParam));
    }

    return collection;
  }

  static count() {
    return new Observable((observer) => {
      const count = 0;
      this.getAll().subscribe(
        (results) => {
          observer.next(results.length);
          observer.complete();
        },
        (err) => {
          observer.error(err);
        }
      );
    });
  }

  static exportToJson(){
    let json = {};
    return new Observable(observer=>{
      this.getAll().subscribe(documents=>{
        json[this['__name']] = [];

        documents.forEach(document=>{
          json[this['__name']].push(document.toJson());
        })
        observer.next(JSON.stringify(json));
        observer.complete()
      })
    })
    
  }

  static getAll(query = null, orderBy = null): Observable<any[]> {
    const db = this.getAngularFirestore();
    const objetos = [];
    Document.prerequisitos(this['__name'], db);

    // TODO: migrar os códigos acima para dentro do observable, em um try/catch e no catch, em caso de erro, lançar um observer.error
    return new Observable((observer) => {
      // let collection: any = this.buildCollection(db, this["__name"], null);
      const collection = this.buildCollection(db, this['__name'], query, orderBy);

      collection.get({ source: 'server' }).subscribe(
        (resultados) => {
          const i = 0;
          resultados.docs.forEach((document) => {
            objetos.push(new FireStoreDocument(document).toObject(this['prototype']));
          });
          observer.next(objetos);
          observer.complete();
        },
        (err) => {
          observer.error(err);
        }
      );
    });
  }

  // TODO: incluir a opção de deletar por query
  static deleteAll() {
    const db = this.getAngularFirestore();
    Document.prerequisitos(this['__name'], db);

    return new Observable((observer) => {
      let counter = 0;

      this.getAll().subscribe(
        (resultados) => {
          const documents = [];
          resultados.forEach((documento) => {
            counter++;
            documents.push(this.delete(documento.id));
          });

          if (documents.length > 0) {
            forkJoin(documents).subscribe((resultado) => {
              observer.next(resultado.length);
              observer.complete();
            });
          } else {
            observer.next(counter);
            observer.complete();
          }
        },
        (err) => {
          observer.error(err);
        }
      );
    });
  }

  static delete(id) {
    const db = this.getAngularFirestore();
    Document.prerequisitos(this['__name'], db);

    return new Observable((observer) => {
      const collection: AngularFirestoreCollection<any> = db.collection<any>(this['__name']);
      collection
        .doc(id)
        .delete()
        .then((resultado) => {
          observer.next(true);
          observer.complete();
        })
        .catch((err) => {
          observer.next(false);
          observer.complete();
        });
    });
  }

  /**
   * Verifica se os pré-requisitos para execução de uma operação no Firestore estão sendo atendidos. Os pré-requisitos estabelecidos são: nome da collection e instância do AngularFirestore
   * @param __name nome da collection
   * @param db instância de AngularFirestore
   */
  static prerequisitos(__name, db) {
    if (__name == undefined || __name == null) {
      throw new Error('Não foi atribuído um nome para essa collection.');
    }

    if (db == undefined || db == null) {
      throw new Error('Não há uma instância de AngularFirestore.');
    }
  }

  /**
   * @date annotation does not create date properties in Documents child's class. This method create those properties (empty as they will be populated when sent to database).
   */
  constructDateObjects() {
    if (this['__date'] != undefined && this['__date'].length > 0) {
      this['__date'].forEach((dateObject) => {
        this[dateObject] = '';
      });
    }
  }

  /**
   * Retrievies the primary key of this document.
   */
  pk() {
    return this.id;
  }

  objectToDocument() {
    const object = {};

    const x = Reflect.ownKeys(this);
    Reflect.ownKeys(this).forEach((propriedade) => {
      const propriedadesIgnoradas = this['__ignore'];
      if (
        typeof this[propriedade] != 'function' &&
        typeof this[propriedade] != 'undefined' /* && typeof this[propriedade] != "object"*/
      ) {
        if (
          this['__ignore'] == undefined ||
          (this['__ignore'] != undefined && !this['__ignore'].includes(propriedade))
        ) {
          if (this['__date'] != undefined && this['__date'].includes(propriedade)) {
            object[propriedade] = firebase.firestore.FieldValue.serverTimestamp();
          } else {
            // aqui usar o __oneToOne
            const tipo = typeof this[propriedade];
            if (typeof this[propriedade] == 'object') {
              if (this['__oneToOne'] != undefined && this['__oneToOne'].length > 0) {
                for (let i = 0; i < this['__oneToOne'].length; i++) {
                  if (
                    this['__oneToOne'][i].property == propriedade &&
                    typeof this[propriedade].pk === 'function'
                  ) {
                    object[this['__oneToOne'][i].foreignKeyName] = this[propriedade].pk();
                    break;
                  }
                }
              }
            } else {
              object[propriedade] = this[propriedade];
            }
          }
        }
      }
    });

    if (this.id != undefined) {
      object['id'] = this.id;
    }

    return object;
  }

  save(): Observable<any> {
    Document.prerequisitos(this.constructor['__name'], this.db);

    const ___this = this;

    return new Observable((observer) => {
      try {
        const document = ___this.objectToDocument();

        if (document['id'] != undefined) {
          const docRef = this.db.collection<any>(this.constructor['__name']).doc(document['id']);
          delete document['id']; // id cannot be in the document, as it isnt an attribute.
          docRef
            .update(document)
            .then((result) => {
              observer.next(___this);
              observer.complete();
            })
            .catch((err) => {
              observer.error(err);
            });
        } else {
          const collection: AngularFirestoreCollection<any> = this.db.collection<any>(
            this.constructor['__name']
          );

          collection
            .add(document)
            .then((result) => {
              ___this.id = result.id;
              observer.next(___this);
              observer.complete();
            })
            .catch((err) => {
              observer.error(err);
            });
        }
      } catch (err) {
        observer.error(err);
      }
    });
  }
}