/*
 * ItemSubselectBase is the Framework Demo base class for all subselects used in
 * repositories and other dynamic query building.
 * This class inherits from WYSE's convertable subselect that enables query result row 
 * conversion (extending DbDataReader) and (Hierarchical) Object Relational Mapping.
 * Usage examples (different overloads):
 * - var select = new AddressSelect()  // Gets all addresses
 * - var select = new AddressSelect(id: new Guid("11111111-1111-1111-1111-111111111111"))  // Get a single address by id
 * - var select = new AddressSelect(isDeleted: true)  // Only gets the deleted addresses
 * - var select = new AddressSelect(new PagingSettings { PageNumber = 3, PageSize = 20 })
 * So a Select with WYSE can be used to encapsulate SQL logic,
 * making it kind of like a coded version of a SqlServer function or view,
 * but much more flexible!
 */
protected ItemSubselectBase(
    ItemTableBase<TItem> sourceTable,
    TraceTree parentTraceTree,
    PagingSettings? pagingSettings,  /* If not null then paging is added to the query */
    Guid? id,  /* If not null then a select by id is done */
    bool? isDeleted)  /* If 'null' then both deleted and not deleted */
{
    var traceTree = parentTraceTree?.AddChild();
    traceTree?.RecordCodeConstructorExecution(typeof(ItemSubselectBase<TSelect, TItem>));

    _sourceListConvert = sourceTable.Convert;

    // Funneling is a concept used in WYSE to expose the columns of a (nested)
    // subselect one level higher in a query, so it can be used in a From or in
    // Where/Join expressions for example.
    Id = /*WYSE*/Funnel(sourceTable.Id);
    Created = /*WYSE*/Funnel(sourceTable.Created);
    LastModified = /*WYSE*/Funnel(sourceTable.LastModified);
    IsDeleted = /*WYSE*/Funnel(sourceTable.IsDeleted);

    var columnExpressions = new List</*WYSE*/IExpression>(
        sourceTable./*WYSE*/ListColumns());

    if (pagingSettings is not null)
    {
        // Add SqlServer's 'COUNT(Id) OVER()' to selected columns.
        // The modifying of the Where clause for row selection is done in
        // the query backbone. Check the traces below.
        sourceTable.CountUnpaged = new /*WYSE*/Count(sourceTable.Id).Over();
        CountUnpaged = /*WYSE*/Funnel(sourceTable.CountUnpaged);

        columnExpressions.Add(sourceTable.CountUnpaged);
    }

    // This makes the statement: SELECT [columnExpressions] FROM [sourceList]
    /*WYSE*/From from = this./*WYSE*/Columns(columnExpressions).From(sourceTable);

    // Determine the applicable where clause sub expressions (based on SQL parameters)
    var whereExpressions = new List</*WYSE*/BooleanExpression>();

    if (id.HasValue)
    {
        whereExpressions.Add(
            sourceTable.Id == new /*WYSE*/UniqueIdentifierParam("Id", id));
    }
    if (isDeleted.HasValue)
    {
        whereExpressions.Add(
            sourceTable.IsDeleted == new /*WYSE*/BitParam("IsDeleted", isDeleted));
    }

    if (whereExpressions.Count > 0)
    {
        // Append a Where clause with a condition that is all the
        // sub expressions 'AND'-ed together
        from.Where(whereExpressions./*WYSE*/And());
    }
}

protected async Task<PagedResult<TItem>> GetItemTreesAsync<TItem>(
    Select select,
    PagingSettings pagingSettings,
    Converter<DbDataReader, TItem> converter,
    TraceTree parentTraceTree)
    where TItem : ItemBase
{
    var traceTree = parentTraceTree.AddChild();
    traceTree.RecordCodeMethodExecution(MethodBase.GetCurrentMethod());

    // In Wyse, mappings facilitate Hierarchical Object Relational Mapping.
    // The information to do is reflected/extracted from the Select at runtime.
    // This way you have complete control of how your objects are built and you always
    // have the desired Select/mappings combination.
    // No more no less, in the right place, always. Best efficiency possible.
    // NOTE: Select reflection is based on the implementation of an interface of both
    // the list involved in the join as the (list of) POCO domain object(s).
    // PS: Ad hoc (custom) mapping can be used as well, and in conjunction with reflection.
    var mappings = /*WYSE*/MappingsFactory.GetMappings(select);

    // A scriptable can be anything in the WYSE language that can be part of a script:
    // - Executables; like Selects, Inserts, Updates, Deletes, Merges (SqlServer only)
    // - Variable and Temp table declarations
    // - If/Elses
    // ...and more.
    var scriptables = new List</*WYSE*/IScriptable>();

    _queryBackbone.Using(pagingSettings, traceTree).Modify(select, scriptables);

    var pageItems = await _sqlExecuter.GetScriptItemTreesAsync(
        // Create new script combining scriptables with select
        new Script(scriptables) + select,
        select,
        converter,  /* of the primary/root table, used in the From of the Select */
        mappings,
        parentTraceTree);

    return new PagedResult<TItem>(pagingSettings, pageItems);
}

// Generic mappings are WYSE's way of defining mappings separate from a
// specific Select, in order to facilitate reuse.
public IReadOnlyList</*WYSE*/GenericMapping> GetGenericMappings()
{
    var traceTree = _parentTraceTree?.AddChild();
    traceTree?.RecordCodeMethodExecution(MethodBase.GetCurrentMethod());

    if (_genericMappings is null)
    {
        // Factory for creating generic mappings starting from a
        // 'CustomerSubselect' source list, having a domain object
        // of type 'Customer'
        var factory = new /*WYSE*/GenericMappingsFactory<CustomerSubselect, Customer>();

        _genericMappings = new /*WYSE*/GenericMappingList(
            // Target list is a 'AddressSubselect' and maps to a type 'Address'
            factory.CreateMapping<AddressSubselect, Address>(
                (s, a) => s.HomeAddressId == a.Id,
                c => c.HomeAddress),
            factory.CreateMapping<AddressSubselect, Address>(
                (s, a) => s.BillingAddressId == a.Id,
                c => c.BillingAddress));
    }
    
    return _genericMappings;
}