program SpringExample;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  Spring.Container;

type
  IMove = interface
  ['{A1A2EB2E-A499-4D9A-8D11-FA94EA1F231D}']
    procedure Move;
  end;

  TSwim = class(TInterfacedObject, IMove)
  strict private
    procedure Move;
  end;

  TRun = class(TInterfacedObject, IMove)
  strict private
    procedure Move;
  end;

  TWalk = class(TInterfacedObject, IMove)
  strict private
    procedure Move;
  end;

  IPeople = interface
  ['{0CFC7987-8DE0-4BCB-A78F-99CA46D5DA08}']
    procedure GoToWork;
  end;

  TPeople = class(TInterfacedObject, IPeople)
  strict private
    FMove: IMove;
  public
    constructor Create(const aMove: IMove);
    procedure GoToWork;
  end;

{ TSwim }

procedure TSwim.Move;
begin
  Writeln('I Swim ');
end;

{ TRun }

procedure TRun.Move;
begin
  Writeln('I Run ');
end;

{ TWalk }

procedure TWalk.Move;
begin
  Writeln('I Walk ');
end;

{ TPeople }

constructor TPeople.Create(const aMove: IMove);
begin
  FMove := aMove;
end;

procedure TPeople.GoToWork;
begin
  FMove.Move();
end;

begin
  GlobalContainer.RegisterType<IMove, TSwim>();
//  GlobalContainer.RegisterType<IMove, TRun>();
//  GlobalContainer.RegisterType<IMove, TWalk>();
  GlobalContainer.RegisterType<IPeople, TPeople>();

  GlobalContainer.Build();

  var People := GlobalContainer.Resolve<IPeople>();
  People.GoToWork();
  People := nil;
  Readln;
end.

program SpringExample;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  Spring.Container;

type
  TOrder = class
  end;

  IOrderValidator = interface
  ['{6D0F52B4-A96F-4C96-97A4-DE45324FDE1B}']
    function ValidateOrder(aOrder: TOrder): Boolean;
  end;

  IOrderEntry = interface
  ['{8D272909-3324-4849-A128-C85E249520CD}']
    function EnterOrderIntoDatabase(aOrder: TOrder): Boolean;
  end;

  IOrderProcessor = interface
  ['{978361F2-65F0-49F7-A00C-964C05683682}']
    function ProcessOrder(aOrder: TOrder): Boolean;
  end;

  TOrderEntry = class(TInterfacedObject, IOrderEntry)
  public
    function EnterOrderIntoDatabase(aOrder: TOrder): Boolean;
  end;

  TOrderProcessor = class(TInterfacedObject, IOrderProcessor)
  private
    FOrderValidator: IOrderValidator;
    FOrderEntry: IOrderEntry;
  public
    constructor Create(aOrderValidator: IOrderValidator; aOrderEntry: IOrderEntry);
    function ProcessOrder(aOrder: TOrder): Boolean;
  end;

  TOrderValidator = class(TInterfacedObject, IOrderValidator)
  public
    function ValidateOrder(aOrder: TOrder): Boolean;
  end;

{ TOrderEntry }

function TOrderEntry.EnterOrderIntoDatabase(aOrder: TOrder): Boolean;
begin
  Result := Assigned(aOrder);
  Writeln('Entering order into the database....');
end;

{ TOrderProcessor }

constructor TOrderProcessor.Create(aOrderValidator: IOrderValidator; aOrderEntry: IOrderEntry);
begin
  FOrderValidator := aOrderValidator;
  FOrderEntry := aOrderEntry;
end;

function TOrderProcessor.ProcessOrder(aOrder: TOrder): Boolean;
var
  OrderIsValid: Boolean;
begin
  Result := False;
  OrderIsValid := FOrderValidator.ValidateOrder(aOrder);
  if OrderIsValid then
    Result := FOrderEntry.EnterOrderIntoDatabase(aOrder);
  Writeln('Order has been processed....');
end;

{ TOrderValidator }

function TOrderValidator.ValidateOrder(aOrder: TOrder): Boolean;
begin
  Result := Assigned(aOrder);
  Writeln('Validating Order....');
end;

begin
  GlobalContainer.RegisterType<TOrderEntry>;
  GlobalContainer.RegisterType<TOrderProcessor>;
  GlobalContainer.RegisterType<TOrderValidator>;

  GlobalContainer.Build;

  var Order := TOrder.Create;
  try
    var OrderProcessor := GlobalContainer.Resolve<IOrderProcessor>;
    if OrderProcessor.ProcessOrder(Order) then
      Writeln('Order successfully processed....');
  finally
    Order.Free;
  end;
  Readln;

end.