import Memory = require("dojo/store/Memory");
import Observable = require("dojo/store/Observable");
import { Appointment, Member } from "./Appointment";
import { Contact } from "./Contact";
import { Uuid } from "@implab/core-amd/Uuid";
import { Observable as RxjsObservable } from "rxjs";
import { QueryResultUpdate } from "@implab/djx/tsx";
import {isPromise} from "@implab/core-amd/safe";

type AppointmentRecord = Omit<Appointment, "getMembers"> & {id: string};

type ContactRecord = Contact;

type MemberRecord = Member & { appointmentId: string; };

export interface ObservableResults<T> {
    /**
     * Allows observation of results
     */
    observe(listener: (object: T, previousIndex: number, newIndex: number) => void, includeUpdates?: boolean): {
        remove(): void;
    };
}


export function isObservable<T>(v: unknown): v is ObservableResults<T> {
    return !!v && (typeof (v as {observe?: unknown}).observe === "function");
}

export function observe<T>(results: T[], includeObjectUpdates?: boolean): RxjsObservable<QueryResultUpdate<T>>;
export function observe<T>(results: PromiseLike<T[]>, includeObjectUpdates?: boolean): PromiseLike<RxjsObservable<QueryResultUpdate<T>>>;
export function observe(results: unknown[] | PromiseLike<unknown[]>, includeObjectUpdates = true) {
    // results может быть асинхронным, т.е. до завершения
    // получения результатов store может быть обновлен. В любом
    // случае, если между подключением хотя бы одного наблюдателя
    // была выполнена команда обновления, results считается устаревшим
    // и не может быть использован для отслеживания обновлений.
    // Конкретно с dojo/store/Observable тут вообще возникает проблема:
    // 1. Синхронные store типа Memory будут давать ошибку на методах
    //    обновления (add,put,remove)
    // 2. Асинхронные store типа JsonRest будут выдавать предупреждения
    //    о необработанной ошибке в Promise при обращении к методам
    //    обновления (add,put,remove)

    const _subscribe = (items: unknown[]) => new RxjsObservable<QueryResultUpdate<unknown>>(subscriber => {
        items
            .forEach((value, newIndex) => subscriber.next({ item: value, newIndex, prevIndex: -1}));

        try {
            if (isObservable(results)) {
                const h = results.observe(
                    (value, prevIndex, newIndex) => subscriber.next({
                        item: value,
                        prevIndex,
                        newIndex
                    }),
                    includeObjectUpdates
                );

                return () => { h.remove(); };
            }
        } catch (err) {
            subscriber.error(err);
        }
    });

    return isPromise(results) ?
        results.then(_subscribe) :
        _subscribe(results || []);
}




export class MainContext {
    private readonly _appointments = new Observable(new Memory<AppointmentRecord>());

    private readonly _contacts = new Observable(new Memory<ContactRecord>());

    private readonly _members = new Observable(new Memory<MemberRecord>());

    createAppointment(title: string, startAt: Date, duration: number, members: Member[]) {
        const id = Uuid();
        this._appointments.add({
            id: Uuid(),
            startAt,
            duration,
            title
        });

        members.forEach(member =>
            this._members.add({
                appointmentId: id,
                ...member
            }, {id: Uuid()}) as void
        );
    }

    queryAppointments(dateFrom: Date, dateTo: Date) {
        //this._appointments.query().map()
    }

    private readonly _mapAppointment = ({startAt, title, duration, id}: AppointmentRecord) => ({

    });

}