import { Format } from '../../../helpers/format.helper';
import { Paging } from '@creedinteractive/onguard-models';

export type ValueFormatter = (value: string) => string;

export type ValueCompare = (a: any, b: any) => number;

export function defaultSort(a: any, b: any): number {
    if (a < b) { return -1; }
    if (b < a) { return 1; }
    return 0;
}


export type ColumnSettings<T> = {
    [K in keyof T]?: ColumnOptions;
};

export function ColumnSettingsFactory<T>(obj: T, defaultWidth: number = null): void {
    const settings = {};
    Object.keys(obj).forEach((key, index) => {
        settings[key] = new ColumnOptions({
            displayName: Format.spaceCamelCase(key),
            width: defaultWidth,
            order: index,
            displayType: 'column'
        });
    });
}

export class ColumnOptions {
    displayName: string = null;
    width: number | null = null; // null widths will not be displayed in the row
    order: number;
    displayType: 'none' | 'column' | 'drawer' = 'column';
    sort: 'asc' | 'desc' | false = false;
    compareValues: ValueCompare = defaultSort;
    formatValue: ValueFormatter = (value: string) => value;

    public constructor(partial: Partial<ColumnOptions>) {
        Object.keys(partial).forEach(key => {
            this[key] = partial[key];
        });
    }

}

export class SortableColumn {
    name = '';
    sort: 'asc' | 'desc' | false = false;
}


export class Table<T> {
    label = '';
    widths: any;
    data: T[];
    sorting: SortableColumn[];
    keys: string[];
    columnSettings: ColumnSettings<T>;
    paging: Paging;

    constructor(data: T[], label?: string, settings?: ColumnSettings<T>, paging?: Paging) {
        if (!data) {
            console.error('Creating a table with no data');
            return;
        }
        this.data = data;

        this.paging = paging || new Paging(data.length);
        this.paging.pageCount = Math.ceil(data.length / this.paging.perPage);

        this.label = label || null;
        this.columnSettings = settings || new ColumnSettingsFactory(data[0]);

        this.keys = Object.keys(this.columnSettings).sort((a, b) => {
            return this.columnSettings[a].order - this.columnSettings[b].order;
        });

        let hasInitialSort = false;
        this.sorting = [];
        this.keys.forEach(key => {
            this.sorting.push({
                name: key,
                sort: this.columnSettings[key].sort
            });
            if (this.columnSettings[key].sort) {
                hasInitialSort = true;
            }
        });

        if (!hasInitialSort && this.sorting[0]) {
            this.sorting[0].sort = 'asc';
        }

    }
}