unit Myc.Trade.DataProvider;

interface

uses
    Myc.Signals,
    Myc.Lazy,
    Myc.Trade.DataPoint,
    Myc.Trade.DataStream;

type
    TDataStreamProvider<T> = class(TInterfacedObject, TMutable<TDataSeries<T>>.IMutable)
    private
        FStream: IDataStream<T>;
        FDataSeries: TDataSeries<T>;
        FNewDataAvailable: TFlag;
        FHasDataSubscription: TSignal.TSubscription;
        FLookback: Int64;
        function GetChanged: TSignal;
        function GetValue: TDataSeries<T>;
    public
        constructor Create(ALookback: Int64; const AStream: IDataStream<T>);
        destructor Destroy; override;
    end;

    TDataStreamProvider = record
        class function Create<T>(Lookback: Int64; const Stream: IDataStream<T>): TMutable<TDataSeries<T>>; static;
    end;

implementation

{ TDataStreamProvider<T> }

constructor TDataStreamProvider<T>.Create(ALookback: Int64; const AStream: IDataStream<T>);
begin
    inherited Create;
    FLookback := ALookback;
    FStream := AStream;
    FHasDataSubscription := FStream.HasData.Subscribe(FNewDataAvailable);
    FDataSeries := TDataSeries<T>.Create( ALookback );
end;

destructor TDataStreamProvider<T>.Destroy;
begin
    FHasDataSubscription.Unsubscribe;
    inherited;
end;

function TDataStreamProvider<T>.GetChanged: TSignal;
begin
    Result := FStream.HasData;
end;

function TDataStreamProvider<T>.GetValue: TDataSeries<T>;
begin
    if FNewDataAvailable.Reset then
    begin
        var Data: array[0..1024 - 1] of TDataPoint<T>;
        var cnt := FStream.GetChunk(Data);
        while cnt > 0 do
        begin
            FDataSeries.Add(Data, cnt);
            cnt := FStream.GetChunk(Data);
        end;
    end;
    Result := FDataSeries;
end;

{ TDataStreamProvider }

class function TDataStreamProvider.Create<T>(Lookback: Int64; const Stream: IDataStream<T>): TMutable<TDataSeries<T>>;
begin
    Result := TDataStreamProvider<T>.Create(Lookback, Stream);
end;

end.