unit JDRMBuffer;

//This unit contains all necessary functionality to handle incoming
// socket data and trigger events when new FULL sets of data are available.

interface


uses
  Windows, SysUtils, Classes, StrUtils{, JDRMPackets};

type
  TJDRMBuffer = class;
  TJDRMCustomBuffer = class;


  TJDRMBufferType = (btText, btStream);
  //Two modes, strictly one or the other only


  TJDRMBufferStreamEvent = procedure(Sender: TObject; Stream: TMemoryStream) of object;
  TJDRMBufferPacketEvent = procedure(Sender: TObject; Packet: String) of object;


  TJDRMCustomBuffer = class(TComponent)
  private
    fStream: TMemoryStream;
    fBuffer: String;
    fType: TJDRMBufferType;
    fStreamSize: Integer;
    fStreamRec: Integer;
    fReceiving: Boolean;

    fStreamEvent: TJDRMBufferStreamEvent;
    fPacketEvent: TJDRMBufferPacketEvent;

    procedure NewStream(Stream: TMemoryStream);
    procedure NewPacket(Packet: String);

    function GetSize: Integer;
    function GetStreamSize: Integer;

    procedure SetStreamSize(Value: Integer);
    procedure SetType(Value: TJDRMBufferType);

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    procedure Add(Data: String);
    function GetNextPacket: String;
    procedure Clear;
    procedure Reset;

    property Data: String read fBuffer;
    property DataSize: Integer read GetSize;
    property StreamSize: Integer read fStreamSize write fStreamSize;
    property BufferType: TJDRMBufferType read fType write SetType;

    property OnStream: TJDRMBufferStreamEvent
      read fStreamEvent write fStreamEvent;
    property OnPacket: TJDRMBufferPacketEvent
      read fPacketEvent write fPacketEvent;

  end;

  TJDRMBuffer = class(TJDRMCustomBuffer)
  published
    property Data;
    property DataSize;
    property StreamSize;
    property BufferType;

    property OnStream;
    property OnPacket;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('JD Remote Desktop', [TJDRMBuffer]);
end;



constructor TJDRMCustomBuffer.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  Self.fStream:= TMemoryStream.Create;
  Self.fBuffer:= '';
  Self.fType:= btText;
  Self.fReceiving:= False;
end;

destructor TJDRMCustomBuffer.Destroy;
begin

  Self.fStream.Clear;
  Self.fStream.Free;
  inherited Destroy;
end;

procedure TJDRMCustomBuffer.SetType(Value: TJDRMBufferType);
begin
  Self.fType:= Value;
  if Value = btStream then begin
    Self.fStreamRec:= 0;
  end;
end;

function TJDRMCustomBuffer.GetStreamSize: Integer;
begin
  Result:= Self.fStream.Size;
end;

procedure TJDRMCustomBuffer.SetStreamSize(Value: Integer);
begin
  Self.fStream.Size:= Value;
end;

function TJDRMCustomBuffer.GetSize: Integer;
begin
  Result:= Length(Self.fBuffer);
end;

//This is the universal procedure to add new data to the buffer.
//As data is added to buffer, it needs to recognize if the packet is complete
// or not. If it is complete, it needs to trigger the proper event.
// It also needs to recognize when there's more data than expected
// and carry it on to the next stream. It may be possible for two streams
// to get combined together

procedure TJDRMCustomBuffer.Add(Data: String);
var
  SL: String;   //??? (copied source)
  ID: String;   //Incoming data (used for streaming)
begin
  if Self.fType = btStream then begin //If component is in the stream mode
    if not Self.fReceiving then begin
      //Begin receiving stream
      SetLength(SL, StrLen(PChar(Data)) + 1);         //??? (copied source)
      StrLCopy(@SL[1], PChar(Data), Length(SL) - 1);  //??? (copied source)
      Self.fStreamSize:= StrToIntDef(SL, 0);          //Tell component how much data to expect
      Delete(Data, 1, Length(SL));                    //Remove the pre-defined data size
      Self.fStream.Write(Data[1], Length(Data));      //Write the actual data to stream
      Self.fReceiving:= True;                         //Tell component it's receiving
    end else begin

      //AREA WHERE I NEED HELP!

      //Check size of data compared to size expected
      if Length(Data) > (Self.fStreamSize - Self.fStream.Size) then
      begin
        //More data received than expected, only add necessary data
        ID:= Copy(Data, 1, Self.fStreamSize - Self.fStream.Size);
        //Save extra data to new temporary location
          //(and later add to stream)

      end else begin
        ID:= Data;  //Simply just add new data to stream
      end;

      //Add data to stream
      Self.fStream.Write(ID[1], Length(ID));

      //Check if all data has been received
      if (Self.fStream.Size = Self.fStreamSize) then begin
        //All data has arrived, trigger new event
        Self.fReceiving:= False;      //No longer receiving
        Self.fStream.Position:= 0;    //Set position to beginning
        Self.NewStream(Self.fStream); //Trigger new stream event
        Self.fStream.Clear;           //Clear stream for new data
      end;

    end;
  end else begin
    //Simply add new data to buffer string
    Self.fBuffer:= Self.fBuffer + Data;

    //Check for a newly complete packet
    //(Should I run this on a timer instead?)
  end;
end;

procedure TJDRMCustomBuffer.Clear;
begin
  Self.fBuffer:= '';
  Self.fStream.Clear;
end;

procedure TJDRMCustomBuffer.Reset;
begin
  Self.Clear;
  Self.fType:= btText;
end;

//I will be removing this once I get the events working
function TJDRMCustomBuffer.GetNextPacket: String;    {
var
  P: Integer;    }
begin   {
  //Check if new packet is available
  P:= pos(JDRMPacketFooter, Self.fBuffer);
  if Self.fType = btStream then begin
    //Check if there's more data than expected
    if Self.GetSize > (Self.fStreamSize - Self.fStreamRec) then begin
      //There's more available than expected

    end else begin


    end;

    if P > 0 then begin
      Result:= Copy(Self.fBuffer, 1, P + Length(JDRMPacketFooter));
      Delete(Self.fBuffer, 1, P + Length(JDRMPacketFooter));
    end else begin
      Result:= Self.fBuffer;
      Self.Clear;
    end;
  end else begin
    if P > 0 then begin
      Result:= Copy(Self.fBuffer, 1, P + Length(JDRMPacketFooter));
      Delete(Self.fBuffer, 1, P + Length(JDRMPacketFooter));
    end else begin
      Result:= '';
    end;
  end; }
end;


procedure TJDRMCustomBuffer.NewStream(Stream: TMemoryStream);
begin
  if assigned(Self.fStreamEvent) then begin
    Self.fStreamEvent(Self, Stream);
  end;
end;

procedure TJDRMCustomBuffer.NewPacket(Packet: String);
begin
  if assigned(Self.fPacketEvent) then begin
    Self.fPacketEvent(Self, Packet);
  end;
end;


end.