using InABox.Clients;
using InABox.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace InABox.DynamicGrid;

public interface IDynamicGridDataComponent<T>
    where T : BaseObject, new()
{
    DynamicGrid<T> Grid { get; }

    void Reload(Filters<T> criteria, Columns<T> columns, SortOrder<T>? sort, CancellationToken token, Action<QueryResult> action);

    T LoadItem(CoreRow row);

    T[] LoadItems(CoreRow[] rows);

    void SaveItem(T item);

    void SaveItems(T[] items);

    void DeleteItems(CoreRow[] rows);

    /// <summary>
    /// Loads the child tables for an export, based on the filter of the parent table.
    /// </summary>
    /// <param name="filter">Filter for the parent table.</param>
    /// <param name="tableColumns">A list of the child table types, with columns to load for each</param>
    /// <returns>A list of tables, in the same order as they came in <paramref name="tableColumns"/></returns>
    IEnumerable<Tuple<Type?, CoreTable>> LoadExportTables(Filters<T> filter, IEnumerable<Tuple<Type, IColumns>> tableColumns);

    CoreTable LoadImportKeys(string[] fields);
}

public abstract class BaseDynamicGridDataComponent<T> : IDynamicGridDataComponent<T>
    where T : BaseObject, new()
{
    public DynamicGrid<T> Grid { get; private set; }

    public BaseDynamicGridDataComponent(DynamicGrid<T> grid)
    {
        Grid = grid;
    }

    public abstract void DeleteItems(CoreRow[] rows);

    public abstract T LoadItem(CoreRow row);

    public virtual T[] LoadItems(CoreRow[] rows) => rows.ToArray(LoadItem);

    public abstract void Reload(Filters<T> criteria, Columns<T> columns, SortOrder<T>? sort, CancellationToken token, Action<QueryResult> action);

    public abstract void SaveItem(T item);

    public virtual void SaveItems(T[] items)
    {
        foreach(var item in items)
        {
            SaveItem(item);
        }
    }

    public virtual IEnumerable<Tuple<Type?, CoreTable>> LoadExportTables(Filters<T> filter, IEnumerable<Tuple<Type, IColumns>> tableColumns)
    {
        return tableColumns.Select(x =>
        {
            var table = new CoreTable();
            table.LoadColumns(x.Item2);
            return new Tuple<Type?, CoreTable>(x.Item1, table);
        });
    }

    public virtual CoreTable LoadImportKeys(String[] fields)
    {
        var result = new CoreTable();
        result.LoadColumns(Columns.None<T>().Add(fields));
        return result;
    }

}