Enterprise FizzBuzz - Pascal

program TestConsole;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  Spring.Collections,
  System.Math,
  System.Classes,
  System.SyncObjs,
  System.SysUtils;

type
  mlMainLoop = class(TObject)
    strict private
    const
      DEFAULT_OUTPUT_STRING = '';
    var
      fUserInput: string;
      fConsoleOutput: string;
      fCurrentMainLoopIteration: Integer;
    procedure IncrementIterationCounter;

    public
    procedure Init;
    procedure ExecuteBody;
  end;

  IFizzBuzzable = interface
    ['{194D5B44-11B6-44F7-B255-ECCF686285CE}']
    function IsFizz: Boolean;
    function IsBuzz: Boolean;
    function IsFizzBuzz: Boolean;
  end;

  IPrintable = interface
    ['{60FC51C9-FDF3-4804-9822-D7C69B98B843}']
    function PrintStr: string;
  end;

  IFizzBuzzableManager = interface
    ['{3F2E9739-55A7-4AB0-A0F5-71005140BFCD}']
    procedure NewFizzBuzzable(const aValue: Cardinal);
    function Count: Cardinal;
    function GetPrintable(const aValue: Cardinal): IPrintable;
  end;

  TFizzBuzzable = class(TInterfacedObject, IFizzBuzzable, IPrintable)
  strict private
    fValue: Cardinal;
  public
    constructor Create(const aValue: Cardinal);
    function IsFizz: Boolean;
    function IsBuzz: Boolean;
    function IsFizzBuzz: Boolean;
    function PrintStr: string;
  end;

  TFizzBuzzableManager = class(TInterfacedObject, IFizzBuzzableManager)
  strict private
    fFizzBuzzables: Spring.Collections.IDictionary<Cardinal, IFizzBuzzable>;
  public
    procedure AfterConstruction; override;
    procedure NewFizzBuzzable(const aValue: Cardinal);
    function Count: Cardinal;
    function GetPrintable(const aValue: Cardinal): IPrintable;
  end;

  TFizzBuzzer = class
  strict private
    fCount:               Cardinal;
    fFizzBuzzableManager: IFizzBuzzableManager;
  public
    constructor Create(const aCount: Cardinal);
    function FizzBuzz: string;
  end;

  const
    C_FIZZ = 'Fizz';
    C_BUZZ = 'Buzz';

var
  fmlMainLoop: mlMainLoop;

procedure mlMainLoop.Init;
begin
  fCurrentMainLoopIteration := 0;
  fUserInput := '';
  fConsoleOutput := DEFAULT_OUTPUT_STRING;
end;

procedure mlMainLoop.ExecuteBody;

var
  vFizzBuzzer: TFizzBuzzer;

begin
  Readln(fUserInput);

  vFizzBuzzer := TFizzBuzzer.Create(StrToInt(fUserInput));
  try
    fConsoleOutput := vFizzBuzzer.FizzBuzz();
  finally
    vFizzBuzzer.Free();
  end;

  Writeln(fConsoleOutput);
  IncrementIterationCounter;
end;

procedure mlMainLoop.IncrementIterationCounter;
begin
  fCurrentMainLoopIteration := fCurrentMainLoopIteration + 1;
end;

{ TFizzBuzzable }

constructor TFizzBuzzable.Create(const aValue: Cardinal);
begin
  fValue := aValue;
end;

function TFizzBuzzable.IsBuzz: Boolean;
begin
  Result := (fValue mod 5) = 0;
end;

function TFizzBuzzable.IsFizz: Boolean;
begin
  Result := (fValue mod 3) = 0;
end;

function TFizzBuzzable.IsFizzBuzz: Boolean;
begin
  Result := IsBuzz and IsFizz;
end;

function TFizzBuzzable.PrintStr: string;
begin
  if IsFizzBuzz then
    Result := C_FIZZ + C_BUZZ
  else
  if IsFizz then
    Result := C_FIZZ
  else
  if IsBuzz then
    Result := C_BUZZ
  else
    Result := Format('%d', [fValue]);
end;

{ TFizzBuzzableManager }

procedure TFizzBuzzableManager.AfterConstruction;
begin
  inherited;
  fFizzBuzzables := Spring.Collections.TCollections.CreateDictionary<Cardinal, IFizzBuzzable>();
end;

function TFizzBuzzableManager.Count: Cardinal;
begin
  Result := fFizzBuzzables.Count;
end;

function TFizzBuzzableManager.GetPrintable(const aValue: Cardinal): IPrintable;
begin
  Result := nil;
  if fFizzBuzzables.Keys.Contains(aValue) then
    Supports(fFizzBuzzables[aValue], IPrintable, Result);
end;

procedure TFizzBuzzableManager.NewFizzBuzzable(const aValue: Cardinal);
begin
  fFizzBuzzables.AddOrSetValue(aValue, TFizzBuzzable.Create(aValue));
end;

{ TFizzBuzzer }

constructor TFizzBuzzer.Create(const aCount: Cardinal);
var
  I: Integer;
begin
  fCount := aCount;
  fFizzBuzzableManager := TFizzBuzzableManager.Create();
  for I := 1 to aCount do
    fFizzBuzzableManager.NewFizzBuzzable(I);
end;

function TFizzBuzzer.FizzBuzz: string;
var
  I: Cardinal;
begin
  Result := EmptyStr;
  for I := 1 to fFizzBuzzableManager.Count() do
    Result := Format('%s%s%s', [Result, sLineBreak,
      fFizzBuzzableManager.GetPrintable(I).PrintStr()]);
end;

begin
  fmlMainLoop := mlMainLoop.Create;
  fmlMainLoop.Init;
  while True do
  begin
    try
      fmlMainLoop.ExecuteBody;
    except
      on E: Exception do
        Writeln(E.ClassName, ': ', E.Message);
    end;
  end;
  fmlMainLoop.Free;
end.