type Primitive = string | number | Date | boolean

export class ODataFilter<T> {
    private filterParts: Array<string> = []

    private getFormattedValue(value: Primitive | unknown): string {
        if (typeof value === 'string') {
            return `'${value.replace(/'/g, '%27%27')}'`
        } else if (value instanceof Date) {
            return `datetimeoffset'${value.toISOString()}'`
        } else if (typeof value === 'undefined' || value === null) {
            return 'null'
        } else {
            return value.toString()
        }
    }

    private addCondition(condition: string) {
        this.filterParts.push(condition)
    }

    eq<K extends keyof T>(field: K, value: T[K]): ODataFilter<T> {
        this.addCondition(`${String(field)} eq ${this.getFormattedValue(value)}`)
        return this
    }

    ne<K extends keyof T>(field: K, value: T[K]): ODataFilter<T> {
        this.addCondition(`${String(field)} ne ${this.getFormattedValue(value)}`)
        return this
    }

    gt<K extends keyof T>(field: K, value: T[K] | Date): ODataFilter<T> {
        this.addCondition(`${String(field)} gt ${this.getFormattedValue(value)}`)
        return this
    }

    ge<K extends keyof T>(field: K, value: T[K] | Date): ODataFilter<T> {
        this.addCondition(`${String(field)} ge ${this.getFormattedValue(value)}`)
        return this
    }

    lt<K extends keyof T>(field: K, value: T[K] | Date): ODataFilter<T> {
        this.addCondition(`${String(field)} lt ${this.getFormattedValue(value)}`)
        return this
    }

    le<K extends keyof T>(field: K, value: T[K] | Date): ODataFilter<T> {
        this.addCondition(`${String(field)} le ${this.getFormattedValue(value)}`)
        return this
    }

    in<K extends keyof T>(field: K, values: Array<T[K]>): ODataFilter<T> {
        const formattedValues = values.map((v) => this.getFormattedValue(v)).join(',')
        this.addCondition(`${String(field)} in (${formattedValues})`)
        return this
    }

    startsWith<K extends keyof T>(field: K, value: string): ODataFilter<T> {
        this.addCondition(`startswith(${String(field)}, ${this.getFormattedValue(value)})`)
        return this
    }

    endsWith<K extends keyof T>(field: K, value: string): ODataFilter<T> {
        this.addCondition(`endswith(${String(field)}, ${this.getFormattedValue(value)})`)
        return this
    }

    contains<K extends keyof T>(field: K, value: string): ODataFilter<T> {
        this.addCondition(`contains(${String(field)}, ${this.getFormattedValue(value)})`)
        return this
    }

    includes<K extends keyof T>(field: K, value: string): ODataFilter<T> {
        this.addCondition(`substringof(${this.getFormattedValue(value)}, ${String(field)}) eq true`)
        return this
    }

    notIncludes<K extends keyof T>(field: K, value: string): ODataFilter<T> {
        this.addCondition(`substringof(${this.getFormattedValue(value)}, ${String(field)}) eq false`)
        return this
    }

    and(filterBuilder: (filter: ODataFilter<T>) => ODataFilter<T>): ODataFilter<T> {
        const newFilter = filterBuilder(new ODataFilter<T>())
        if (newFilter.filterParts.length > 0) {
            if (this.filterParts.length > 0) {
                this.addCondition(`${this.toString()} and (${newFilter})`)
            } else {
                this.addCondition(`(${newFilter})`)
            }
            this.filterParts = [this.filterParts.pop()!] // keep only the latest compound condition
        }
        return this
    }

    or(filterBuilder: (filter: ODataFilter<T>) => ODataFilter<T>): ODataFilter<T> {
        const newFilter = filterBuilder(new ODataFilter<T>())
        if (newFilter.filterParts.length > 0) {
            if (this.filterParts.length > 0) {
                this.addCondition(`${this.toString()} or (${newFilter})`)
            } else {
                this.addCondition(`(${newFilter})`)
            }
            this.filterParts = [this.filterParts.pop()!] // keep only the latest compound condition
        }
        return this
    }

    toString(): string {
        return this.filterParts.join(' and ')
    }
}

export const filter = <T>(): ODataFilter<T> => new ODataFilter<T>()