import { Environment } from "@rdfjs/environment/Environment.js";
import {
    BlankNode,
    DataFactory,
    DatasetCore,
    DatasetCoreFactory,
    Literal,
    NamedNode,
    Quad_Graph,
    Term,
} from "@rdfjs/types";
import Context from "./lib/Context.js";

export type AnyContext = Term | Term[] | undefined;

type TermOrClownface<X extends Term = Term> = MultiPointer<X> | X;
type TermOrLiteral<X extends Term = Term> = TermOrClownface<X> | string | number | boolean;

type AddCallback<D extends DatasetCore, X extends Term> = (added: AnyPointer<X, D>) => void;
type SingleOrArray<T> = T | readonly T[] | Iterable<T>;
type SingleOrOneElementArray<T> = T | readonly [T];

type SingleOrArrayOfTerms<X extends Term> = SingleOrArray<X> | MultiPointer<X>;
type SingleOrArrayOfTermsOrLiterals<X extends Term> = SingleOrArray<TermOrLiteral<X>>;

interface NodeOptions {
    type?: "BlankNode" | "Literal" | "NamedNode" | undefined;
    datatype?: Term | { toString(): string } | undefined;
    language?: string | undefined;
}

export type ClownfaceInit<D extends DatasetCore = DatasetCore> = Partial<
    Pick<AnyPointer<AnyContext, D>, "dataset" | "_context"> & {
        graph: Quad_Graph;
        factory: Environment<DatasetCoreFactory | DataFactory>;
    }
>;

type Iteratee<T extends AnyContext = undefined, D extends DatasetCore = DatasetCore> = T extends undefined ? never
    : T extends any[] ? AnyPointer<T[0], D>
    : AnyPointer<T, D>;

type Predicate<T extends AnyContext = undefined, D extends DatasetCore = DatasetCore> = T extends undefined ? never
    : T extends any[] ? Iteratee<T[0], D>
    : Iteratee<T, D>;

type ExtractContext<T extends AnyContext> = T extends undefined ? never : T extends any[] ? T[0] : T;

export type FilterCallback<T extends AnyContext = AnyContext, D extends DatasetCore = DatasetCore, S extends T = T> = (
    ptr: Iteratee<T, D>,
    index: number,
    pointers: Array<GraphPointer<ExtractContext<T>>>,
) => ptr is Predicate<S, any>;

interface OutOptions {
    language?: string | string[] | undefined;
}

export interface AnyPointer<T extends AnyContext = AnyContext, D extends DatasetCore = DatasetCore> {
    readonly term: T extends undefined ? undefined : T extends any[] ? undefined | T[0] : T;
    readonly terms: T extends undefined ? Term[] : T extends any[] ? T : [T];
    readonly value: T extends undefined ? undefined : T extends any[] ? undefined | string[0] : string;
    readonly values: T extends undefined ? string[] : T extends any[] ? string[] : [string];
    readonly dataset: D;
    readonly datasets: D[];
    readonly _context: Array<Context<D, Term>>;

    any(): AnyPointer<AnyContext, D>;

    list(): Iterable<GraphPointer<Term, D>> | null;

    isList(): this is T extends BlankNode | NamedNode ? ListPointer<T, D> : never;

    toArray(): Array<AnyPointer<ExtractContext<T>, D>>;

    filter<S extends T>(cb: FilterCallback<T, D, S>): AnyPointer<S, D>;

    filter(
        cb: (ptr: Iteratee<T, D>, index: number, pointers: Array<GraphPointer<ExtractContext<T>>>) => boolean,
    ): AnyPointer<T, D>;

    forEach(cb: (quad: Iteratee<T, D>) => void): this;

    map<X>(cb: (quad: Iteratee<T, D>, index: number) => X): X[];

    node(value: SingleOrOneElementArray<boolean | string | number>, options?: NodeOptions): AnyPointer<Literal, D>;

    node(values: Iterable<boolean | string | number>, options?: NodeOptions): AnyPointer<Literal[], D>;

    node<X extends Term>(value: SingleOrOneElementArray<X> | AnyPointer<X, D>, options?: NodeOptions): AnyPointer<X, D>;

    node<X extends Term>(value: MultiPointer<X, D> | Iterable<X>, options?: NodeOptions): AnyPointer<X[], D>;

    node<X extends Term>(value: Iterable<GraphPointer<X, D>>, options?: NodeOptions): MultiPointer<X, D>;

    node<X extends Term[]>(values: X, options?: NodeOptions): AnyPointer<X, D>;

    node(value: null, options?: NodeOptions): AnyPointer<BlankNode, D>;

    node(values: null[] | Iterable<BlankNode>, options?: NodeOptions): AnyPointer<BlankNode[], D>;

    node(
        values: Iterable<boolean | string | number | Term | null>,
        options?: NodeOptions,
    ): AnyPointer<Term[], D>;

    blankNode(value?: SingleOrOneElementArray<string> | AnyPointer<BlankNode, D>): AnyPointer<BlankNode, D>;

    blankNode(
        values: MultiPointer<BlankNode, D> | Iterable<BlankNode | string> | Iterable<GraphPointer<BlankNode, D>>,
    ): AnyPointer<BlankNode[], D>;

    literal(
        value: SingleOrOneElementArray<boolean | string | number | Term | null> | AnyPointer<Literal, D>,
        languageOrDatatype?: string | NamedNode,
    ): AnyPointer<Literal, D>;

    literal(
        values:
            | Iterable<boolean | string | number | null | Literal>
            | MultiPointer<Literal, D>
            | Iterable<GraphPointer<Literal, D>>,
        languageOrDatatype?: string | NamedNode,
    ): AnyPointer<Literal[], D>;

    namedNode<Iri extends string = string>(
        value: SingleOrOneElementArray<string | NamedNode<Iri> | AnyPointer<NamedNode<Iri>, D>>,
    ): AnyPointer<NamedNode<Iri>, D>;

    namedNode(
        values:
            | Iterable<string | NamedNode>
            | MultiPointer<NamedNode, D>
            | Iterable<GraphPointer<NamedNode, D>>,
    ): AnyPointer<NamedNode[], D>;

    in(predicates?: SingleOrArrayOfTerms<Term>): MultiPointer<T extends undefined ? never : NamedNode | BlankNode, D>;

    out(predicates?: SingleOrArrayOfTerms<Term>): MultiPointer<T extends undefined ? never : Term, D>;

    out(
        predicates?: SingleOrArrayOfTerms<Term>,
        options?: OutOptions,
    ): MultiPointer<T extends undefined ? never : Literal, D>;

    has(
        predicates: SingleOrArrayOfTerms<Term>,
        objects?: SingleOrArrayOfTermsOrLiterals<Term>,
    ): AnyPointer<Array<NamedNode | BlankNode>, D>;

    addIn(predicates: SingleOrArrayOfTerms<Term>, callback?: AddCallback<D, BlankNode>): AnyPointer<T, D>;

    addIn(
        predicates: SingleOrArrayOfTerms<Term>,
        bnode: SingleOrOneElementArray<null | undefined>,
        callback?: AddCallback<D, BlankNode>,
    ): AnyPointer<T, D>;

    addIn<X extends Term = Term>(
        predicates: SingleOrArrayOfTerms<Term>,
        subjects: SingleOrArrayOfTermsOrLiterals<X>,
        callback?: AddCallback<D, X>,
    ): AnyPointer<T, D>;

    addOut(predicates: SingleOrArrayOfTerms<Term>, callback?: AddCallback<D, BlankNode>): AnyPointer<T, D>;

    addOut(
        predicates: SingleOrArrayOfTerms<Term>,
        bnode: SingleOrOneElementArray<null | undefined>,
        callback?: AddCallback<D, BlankNode>,
    ): AnyPointer<T, D>;

    addOut<X extends Term = Term>(
        predicates: SingleOrArrayOfTerms<Term>,
        objects: SingleOrArrayOfTermsOrLiterals<X>,
        callback?: AddCallback<D, X>,
    ): AnyPointer<T, D>;

    addList<X extends Term = Term>(
        predicates: SingleOrArrayOfTerms<Term>,
        objects?: SingleOrArrayOfTermsOrLiterals<X>,
        callback?: AddCallback<D, X>,
    ): AnyPointer<T, D>;

    deleteIn(predicates?: SingleOrArrayOfTerms<Term>, subjects?: SingleOrArrayOfTerms<Term>): AnyPointer<T, D>;

    deleteOut(predicates?: SingleOrArrayOfTerms<Term>, objects?: SingleOrArrayOfTerms<Term>): AnyPointer<T, D>;

    deleteList(predicates: SingleOrArrayOfTerms<Term>): AnyPointer<T, D>;
}

export interface ListPointer<T extends Term = Term, D extends DatasetCore = DatasetCore> extends GraphPointer<T, D> {
    list(): Iterable<Iteratee<Term, D>>;
}

export type MultiPointer<T extends Term = Term, D extends DatasetCore = DatasetCore> = AnyPointer<T | T[], D>;
export type GraphPointer<T extends Term = Term, D extends DatasetCore = DatasetCore> = AnyPointer<T, D>;

export type ClownfaceInitWithTerms<T extends Term | Term[], D extends DatasetCore> = ClownfaceInit<D> & { term: T };
export type ClownfaceInitWithValue<D extends DatasetCore> = ClownfaceInit<D> & { value: string };
export type ClownfaceInitWithValues<D extends DatasetCore> = ClownfaceInit<D> & { value: string[] };

export interface InitClonePointer {
    <D extends DatasetCore, T extends AnyContext>(other: AnyPointer<T, D>): AnyPointer<T, D>;
}

export interface InitLiteralPointer {
    <D extends DatasetCore>(options: ClownfaceInitWithValue<D>): AnyPointer<Literal, D>;
}

export interface InitLiteralMultiPointer {
    <D extends DatasetCore>(options: ClownfaceInitWithValues<D>): AnyPointer<Literal[], D>;
}

export interface InitPointerFromTerms {
    <D extends DatasetCore, T extends Term | Term[]>(options: ClownfaceInitWithTerms<T, D>): AnyPointer<T, D>;
}

interface InitAnyPointer {
    <D extends DatasetCore>(options: ClownfaceInit<D>): AnyPointer<AnyContext, D>;
}

declare const clownface:
    & InitClonePointer
    & InitLiteralPointer
    & InitLiteralMultiPointer
    & InitPointerFromTerms
    & InitAnyPointer;

export default clownface;