GDK.ToolsAPI.Helper.pas

unit GDK.ToolsAPI.Helper;

interface

uses
  ToolsAPI,
  GDK.ToolsAPI.Helper.Interfaces,
  GDK.ToolsAPI.Debugger.Interfaces,
  System.SysUtils,
  GDK.ToolsAPI.CustomMessage;

type
  TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
  private
    FEditView: IToolsApiEditView;
  public
    function Logger: IToolsApiLogger; overload;
    function Logger(const GroupName: string): IToolsApiLogger; overload;

    function ProjectGroup: IOTAProjectGroup;

    function Project: IToolsApiProject; overload;
    function Project(const Project: IOTAProject): IToolsApiProject; overload;

    function FindProject(const NameOrPath: string): IToolsApiProject;
    procedure SetActiveProject(const Project: IOTAProject);
    function OpenProject(const FileName: string): IToolsApiProject;

    function ProjectContextMenu: IToolsApiProjectContextMenu;

    function BuildConfigurations: IToolsApiBuildConfigurations;
    function EnvironmentOptions: IToolsApiEnvironmentOptions;
    function Debugger: IToolsApiDebugger;

    function ModuleCount: Integer;
    function Module: IToolsApiModule; overload;
    function Module(const Module: IOTAModule): IToolsApiModule; overload;
    function Module(const Index: Integer): IToolsApiModule; overload;

    function SourceEditor: IToolsApiSourceEditor;
    function EditorReader: IToolsApiEditReader;
    function EditorWriter: IToolsApiEditWriter;

    procedure EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
    procedure EditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

    function  EditorPosition: TOTAEditPos;
    function  EditorContent: string;

    function EditView: IToolsApiEditView;
  end;

  TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
  private
    FGroupName: string;
  public
    constructor Create(const GroupName: string);

    function UsesCustomGroup: Boolean;
    function GetGroup: IOTAMessageGroup;

    procedure Clear;

    procedure Log(const Text: string); overload;
    procedure Log(const Text: string; const Params: array of const); overload;

    function Custom: TCustomMessage;
  end;

  TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
  private
    FProject: IOTAProject;
    procedure Guard;
  public
    constructor Create; overload;
    constructor Create(const Project: IOTAProject); overload;

    function Get: IOTAProject;

    function ProjectConfigurations: IOTAProjectOptionsConfigurations;
    function BuildConfigurations: IToolsApiBuildConfigurations;

    function Build(const HideProgressDialog: Boolean = False): Boolean;

    function CreateFormUnit(const UnitFileName: string;
                            const FormName: string;
                            const AncestorName: string = ''): IOTAModule;
  end;

  TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
  private
    FModule: IOTAModule;
    procedure Guard;
    function ReadSourceFromBuffer(out Source: string): Boolean;
  public
    constructor Create; overload;
    constructor Create(const Module: IOTAModule); overload;
    constructor Create(const Index: Integer); overload;

    function Get: IOTAModule;
    function FileCount: Integer;
    function FileName: string;
    procedure Refresh(const ForceRefresh: Boolean);

    function IsDirty: Boolean;
    function MatchesDisk: Boolean;
    procedure SyncWithDisk;

    function Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
    function SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
    function FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
    function FormDesigner: IToolsApiFormEditor;
  end;

  TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
  private
    FEditorServices: IOTAEditorServices;
  public
    constructor Create;

    function TopView: IOTAEditView;
    function CursorPosition: TOTAEditPos;

    procedure InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
  end;

  TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
  private
    FEditor: IOTASourceEditor;
    procedure AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
  public
    constructor Create(const Editor: IOTASourceEditor);

    function Get: IOTASourceEditor;
    function Reader: IToolsApiEditReader;
    function Writer: IToolsApiEditWriter;
    function UndoableWriter: IToolsApiEditWriter;

    procedure AddToInterfaceUses(const UnitName: string); overload;
    procedure AddToInterfaceUses(const UnitNames: TArray<string>); overload;
    procedure AddToImplementationUses(const UnitName: string); overload;
    procedure AddToImplementationUses(const UnitNames: TArray<string>); overload;
  end;

  TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
  private
    FReader: IOTAEditReader;
  public
    constructor Create(const Reader: IOTAEditReader);

    function Get: IOTAEditReader;
    function Content: string;
  end;

  TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
  private
    FWriter: IOTAEditWriter;
  public
    constructor Create(const Writer: IOTAEditWriter);
    function Get: IOTAEditWriter;

    procedure InsertText(const Text: string; const Position: Integer); overload;
    procedure InsertText(const Text: string; const Position: TOTAEditPos); overload;
  end;

  TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
  private
    FProject: IOTAProject;
    FConfigurations: IOTAProjectOptionsConfigurations;
  public
    constructor Create(const Project: IOTAProject);

    function Base: IToolsApiBuildConfiguration;
    function Active: IToolsApiBuildConfiguration;
  end;

  TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
  private
    FOptions: IOTAEnvironmentOptions;
  public
    constructor Create;

    function Get: IOTAEnvironmentOptions;

    function TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
    function GetOption(const OptionName: string): Variant;
    procedure SetOption(const OptionName: string; const Value: Variant);
  end;

  TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
  private
    FConfiguration: IOTABuildConfiguration;

    function  GetSearchPaths: TArray<string>;
    procedure SetSearchPaths(const Paths: TArray<string>);
  public
    constructor Create(const Configuration: IOTABuildConfiguration);
    function Get: IOTABuildConfiguration;

    property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
  end;

implementation

uses
  System.Classes,
  System.IOUtils,
  DCCStrs,
  GDK.ToolsAPI.Debugger,
  GDK.ToolsAPI.FormCreator,
  GDK.ToolsAPI.FormEditor,
  GDK.ToolsAPI.ProjectManagerContextMenu,
  GDK.ToolsAPI.ProjectMatch,
  GDK.ToolsAPI.UsesManager,
  GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

function TToolsApiHelper.Project: IToolsApiProject;
begin
  Result := TToolsApiProject.Create;
end;

function TToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
  Result := TToolsApiProject.Create(Project);
end;

function TToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
  Result := TToolsApiProjectContextMenu.Create;
end;

function TToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
  ModuleServices: IOTAModuleServices;
  Module: IOTAModule;
  ProjectGroup: IOTAProjectGroup;
  i: Integer;
Begin
  ProjectGroup := nil;

  ModuleServices := (BorlandIDEServices as IOTAModuleServices);
  for i := 0 to ModuleServices.ModuleCount - 1 do
  begin
    Module := ModuleServices.Modules[i];
    if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
      Break;
  end;

  Result := ProjectGroup;
end;

function TToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
  Result := nil;

  const Group = ProjectGroup;
  if not Assigned(Group) then
    Exit;

  var FileNames: TArray<string>;
  SetLength(FileNames, Group.ProjectCount);
  for var Index := 0 to Group.ProjectCount - 1 do
    FileNames[Index] := Group.Projects[Index].FileName;

  const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
  if MatchIndex < 0 then
    Exit;

  Result := Project(Group.Projects[MatchIndex]);
end;

procedure TToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
  const Group = ProjectGroup;
  if Assigned(Group) then
    Group.ActiveProject := Project;
end;

function TToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
  Result := nil;

  if not TFile.Exists(FileName) then
    Exit;

  const ActionServices = BorlandIDEServices as IOTAActionServices;
  const Opened = ActionServices.OpenProject(FileName, False);
  if not Opened then
    Exit;

  Result := FindProject(FileName);
end;

function TToolsApiHelper.Module: IToolsApiModule;
begin
  Result := TToolsApiModule.Create;
end;

function TToolsApiHelper.Module(const Module: IOTAModule): IToolsApiModule;
begin
  Result := TToolsApiModule.Create(Module);
end;

function TToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
  Result := TToolsApiModule.Create(Index);
end;

function TToolsApiHelper.ModuleCount: Integer;
var
  ModuleServices: IOTAModuleServices;
begin
  ModuleServices := (BorlandIDEServices as IOTAModuleServices);
  Result := ModuleServices.ModuleCount;
end;

function TToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
  Result := Self.Module.SourceEditor;
end;

function TToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
  ActiveProject: IOTAProject;
begin
  ActiveProject := Self.Project.Get;
  Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

function TToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
  Result := TToolsApiEnvironmentOptions.Create;
end;

function TToolsApiHelper.Debugger: IToolsApiDebugger;
begin
  Result := TToolsApiDebugger.Create;
end;

function TToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
  Result := Self.SourceEditor.Reader;
end;

function TToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
  Self.SourceEditor.Writer;
end;

function TToolsApiHelper.EditView: IToolsApiEditView;
begin
  if not Assigned(FEditView) then
    FEditView := TToolsApiEditView.Create;

  Result := FEditView;
end;

function TToolsApiHelper.Logger: IToolsApiLogger;
begin
  Result := Self.Logger('');
end;

function TToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
  Result := TToolsApiLogger.Create(GroupName);
end;

procedure TToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
  Self.EditView.InsertText(Text, Position);
end;

procedure TToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
  var Lines := string.Join(sLineBreak, Text);
  Self.EditorWriter.InsertText(Lines, AtLine);
end;

function TToolsApiHelper.EditorPosition: TOTAEditPos;
begin
  Result := Self.EditView.CursorPosition;
end;

function TToolsApiHelper.EditorContent: string;
begin
  Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
  inherited Create;
  FProject := GetActiveProject;
  Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
  inherited Create;
  FProject := Project;
  Guard;
end;

function TToolsApiProject.Get: IOTAProject;
begin
  Result := FProject;
end;

function TToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
  Result :=  FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

function TToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
  Result := TToolsApiBuildConfigurations.Create(FProject);
end;

function TToolsApiProject.CreateFormUnit(const UnitFileName: string;
                                         const FormName: string;
                                         const AncestorName: string): IOTAModule;
begin
  const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
  Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

function TToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
  ShowCompilerProgressOption = 'ShowCompilerProgress';
var
  EnvironmentOptions: IToolsApiEnvironmentOptions;
  ExactName: string;
  SavedValue: Variant;
begin
  if not HideProgressDialog then
    Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

  // When a build fails, the compile progress dialog stays open as a modal dialog until the
  // user dismisses it, and BuildProject only returns after that. Temporarily disabling the
  // "Show compiler progress" option keeps unattended builds from blocking.
  EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
  if not EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
    Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

  SavedValue := EnvironmentOptions.GetOption(ExactName);
  EnvironmentOptions.SetOption(ExactName, False);
  try
    Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
  finally
    EnvironmentOptions.SetOption(ExactName, SavedValue);
  end;
end;

procedure TToolsApiProject.Guard;
begin
  if not Assigned(FProject) then
    raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
  inherited Create;
  FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
  Guard;
end;

constructor TToolsApiModule.Create(const Module: IOTAModule);
begin
  inherited Create;
  FModule := Module;
  Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
  inherited Create;
  FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
  Guard;
end;

function TToolsApiModule.Get: IOTAModule;
begin
  Result := FModule;
end;

function TToolsApiModule.FileCount: Integer;
begin
  Result := FModule.GetModuleFileCount;
end;

function TToolsApiModule.FileName: string;
begin
  Result := FModule.FileName;
end;

procedure TToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
  FModule.Refresh(ForceRefresh);
end;

function TToolsApiModule.IsDirty: Boolean;
begin
  Result := False;

  for var Index := 0 to FileCount - 1 do
  begin
    const ModuleEditor = FModule.GetModuleFileEditor(Index);
    if Assigned(ModuleEditor) and ModuleEditor.Modified then
      Exit(True);
  end;
end;

function TToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
  ChunkSize = 4096;
begin
  Source := '';

  var Editor: IOTAEditor := nil;
  for var Index := 0 to FileCount - 1 do
  begin
    const Candidate = FModule.GetModuleFileEditor(Index);
    if Supports(Candidate, IOTASourceEditor) then
    begin
      Editor := Candidate;
      Break;
    end;
  end;

  if not Assigned(Editor) then
    Exit(False);

  const Reader = (Editor as IOTASourceEditor).CreateReader;

  var Bytes: TBytes := nil;
  var Position := 0;
  var Chunk: TBytes;
  SetLength(Chunk, ChunkSize);

  var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
  while BytesRead > 0 do
  begin
    Bytes := Bytes + Copy(Chunk, 0, BytesRead);
    Position := Position + BytesRead;

    if BytesRead < ChunkSize then
      Break;

    BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
  end;

  Source := TEncoding.UTF8.GetString(Bytes);
  Result := True;
end;

function TToolsApiModule.MatchesDisk: Boolean;
begin
  const FilePath = FModule.FileName;
  if (FilePath = '') or (not FileExists(FilePath)) then
    Exit(True);

  var BufferSource: string;
  if not ReadSourceFromBuffer(BufferSource) then
    Exit(True);

  const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

  var DiskSource := '';
  try
    DiskSource := TFile.ReadAllText(FilePath);
  except
    Exit(True);
  end;

  const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
  Result := (BufferNormalized = DiskNormalized);
end;

procedure TToolsApiModule.SyncWithDisk;
begin
  if MatchesDisk then
    Exit;

  if IsDirty then
    raise EToolsApiModuleOutOfSync.CreateFmt(
      '%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

  FModule.Refresh(True);
end;

function TToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
  i: Integer;
  Editor: IOTAEditor;
begin
  Result := nil;

  for i := 0 to FileCount - 1 do
  begin
    Editor := FModule.GetModuleFileEditor(i);
    if Assigned(Predicate) and not Predicate(Editor) then
      Continue;

    Result := Editor;
    Break;
  end;

  if not Assigned(Result) then
    raise EToolsApiNoEditorFound.Create('No editor found.');
end;

function TToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
  Found: IOTAEditor;
  SourceEditor: IOTASourceEditor;
begin
  Found := Editor(
                function(Editor: IOTAEditor): Boolean
                begin
                  Result := Supports(Editor, IOTASourceEditor);
                end);

  SourceEditor := Found as IOTASourceEditor;
  Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

function TToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
  Found: IOTAEditor;
begin
  Found := Editor(
                function(Editor: IOTAEditor): Boolean
                begin
                  Result := Supports(Editor, IOTAFormEditor);
                end);

  Result := Found as IOTAFormEditor;
end;

function TToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
  Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedure TToolsApiModule.Guard;
begin
  if not Assigned(FModule) then
    raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
  inherited Create;
  FEditor := Editor;
end;

function TToolsApiSourceEditor.Get: IOTASourceEditor;
begin
  Result := FEditor;
end;

function TToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
  Reader: IOTAEditReader;
begin
  Reader := FEditor.CreateReader;
  Result := TToolsApiEditReader.Create(Reader);
end;

function TToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
  var Writer := FEditor.CreateWriter;
  Result := TToolsApiEditWriter.Create(Writer);
end;

function TToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
  var Writer := FEditor.CreateUndoableWriter;
  Result := TToolsApiEditWriter.Create(Writer);
end;

procedure TToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
  AddToUses([UnitName], False);
end;

procedure TToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
  AddToUses(UnitNames, False);
end;

procedure TToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
  AddToUses([UnitName], True);
end;

procedure TToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
  AddToUses(UnitNames, True);
end;

procedure TToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
  var UsesBuilder := TToolsAPIUsesBuilder.Use;

  if AddToImplementation then
    UsesBuilder.InImplementation
  else
    UsesBuilder.InInterface;

  var EditorContent := Self.Reader.Content;

  var UsesToWrite := UsesBuilder
                      .WithSource(EditorContent)
                      .Build(UnitNames);

  if UsesToWrite.CanWrite then
    Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
  inherited Create;
  FReader := Reader;
end;

function TToolsApiEditReader.Get: IOTAEditReader;
begin
  Result := FReader;
end;

function TToolsApiEditReader.Content: string;
const
  BufferSize: Integer = 1024;
var
  Read: Integer;
  Position: Integer;
  Buffer: AnsiString;
begin
  Result := '';

  Position := 0;
  repeat
    SetLength(Buffer, BufferSize);

    Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
    SetLength(Buffer, Read);

    Result := Result + string(Buffer);
    Inc(Position, Read);

  until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
  inherited Create;
  FConfiguration := Configuration;
end;

function TToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
  Result := FConfiguration;
end;

function TToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
  Paths: TStringList;
begin
  Paths := TStringList.Create;
  try
    FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

    Result := Paths.ToStringArray;
  finally
    Paths.Free;
  end;
end;

procedure TToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
  SearchPaths: TStringList;
begin
  SearchPaths := TStringList.Create;
  try
    SearchPaths.AddStrings(Paths);
    FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
  finally
    SearchPaths.Free;
  end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
  inherited Create;
  FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

function TToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
  Result := FOptions;
end;

function TToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
  Names: TOTAOptionNameArray;
  Entry: TOTAOptionName;
begin
  Result := False;
  ExactName := '';

  Names := FOptions.GetOptionNames;
  for Entry in Names do
  begin
    if SameText(Entry.Name, OptionName) then
    begin
      ExactName := Entry.Name;
      Exit(True);
    end;
  end;
end;

function TToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
  Result := FOptions.Values[OptionName];
end;

procedure TToolsApiEnvironmentOptions.SetOption(const OptionName: string; const Value: Variant);
begin
  FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
  inherited Create;
  FWriter := Writer;
end;

function TToolsApiEditWriter.Get: IOTAEditWriter;
begin
  Result := FWriter;
end;

procedure TToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
  FWriter.CopyTo(Position);
  FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedure TToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
  EditView: IToolsApiEditView;
begin
  EditView := TToolsApiEditView.Create;
  EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
  inherited Create;
  FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

function TToolsApiEditView.TopView: IOTAEditView;
begin
  Result := FEditorServices.TopView;
  if not Assigned(Result) then
    raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

function TToolsApiEditView.CursorPosition: TOTAEditPos;
begin
  Result := TopView.CursorPos;
end;

procedure TToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
  Line: string;
  EditView: IOTAEditView;
  LineNumber, Col: Integer;
begin
  EditView := TopView;

  LineNumber := Position.Line;
  Col := Position.Col;

  for Line in Text do
  begin
    EditView.Buffer.EditPosition.Move(LineNumber, Col);
    EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

    Inc(LineNumber);
  end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
  inherited Create;
  FProject := Project;
  FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

function TToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
  Config: IOTABuildConfiguration;
begin
  Config := FConfigurations.ActiveConfiguration;
  Result := TToolsApiBuildConfiguration.Create(Config);
end;

function TToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
  Config: IOTABuildConfiguration;
begin
  Config := FConfigurations.BaseConfiguration;
  Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
  inherited Create;
  FGroupName := GroupName;
end;

function TToolsApiLogger.Custom: TCustomMessage;
var
  CustomGroup: IOTAMessageGroup;
begin
  CustomGroup := GetGroup;
  Result := TCustomMessage.Create(CustomGroup);
end;

function TToolsApiLogger.UsesCustomGroup: Boolean;
begin
  Result := (not FGroupName.IsEmpty);
end;

function TToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
  if not Self.UsesCustomGroup then
    raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

  Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedure TToolsApiLogger.Clear;
var
  CustomGroup: IOTAMessageGroup;
begin
  if not Self.UsesCustomGroup then
    Exit;

  CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
  (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedure TToolsApiLogger.Log(const Text: string; const Params: array of const);
var
  FormattedText: string;
begin
  FormattedText := Format(Text, Params);
  Log(FormattedText);
end;

procedure TToolsApiLogger.Log(const Text: string);
var
  LineRef: Pointer;
  CustomGroup: IOTAMessageGroup;
begin
  if Self.UsesCustomGroup then
    CustomGroup := GetGroup
  else
    CustomGroup := nil;

  (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.