unit VCSInfoMenuWzrd;

interface
uses
  System.Generics.Collections,
  ToolsAPI, Vcl.ComCtrls, Vcl.Controls;


type
  TRepoInfo = record
    Root: string;
    IsRepo: Boolean;
    Branch: string;
    Pending: Integer;
    Incoming: Integer;
    Outgoing: Integer;
    LastUpdated: TDateTime;
  end;

  // TODO: implement IOTAEditorNotifier and/or IOTAIDENotifier so we know which file is active
  TVCSInfoWizard = class(TNotifierObject, IOTAWizard, IOTAMenuWizard)
    private
      FRepos: TDictionary<string,TRepoInfo>;

      FToolbar: TToolBar;
      FButtonBranch: TToolButton;
      FButtonSync: TToolButton;

      FImgUnknown: integer;
      FImgNoSync: integer;
      FImgIn: integer;
      FImgOut: integer;
      FImgInOut: integer;
      FImgClean: integer;
      FImgPending: integer;
      FImgExtra: integer;

  actSync: TAction;
  actBranch: TAction;
begin
  Supports(ToolsAPI.BorlandIDEServices, INTAServices, Services);
  Services.MenuBeginUpdate;
  try
    FToolbar := Services.NewToolbar('tlbVCSInfo', 'VCS Info');
    FToolbar.AutoSize := True;

    FImgUnknown :=  AddButtonImage(clBtnShadow);
    FImgNoSync :=   AddButtonImage(clGreen);
    FImgIn :=       AddButtonImage(clRed);
    FImgOut :=      AddButtonImage(clYellow);
    FImgInOut :=    AddButtonImage(clWebOrange);
    FImgClean :=    AddButtonImage(clLime);
    FImgPending :=  AddButtonImage(clBlue);
    FImgExtra :=    AddButtonImage(clFuchsia, 0);















    actSync := TAction.Create(FToolbar);
    actSync.Caption := '(nothing to sync)';
    actSync.Hint := actSync.Caption;
    actSync.Enabled := True;
    actSync.ImageIndex := FImgUnknown;
    actSync.OnExecute := actSyncExecute;
    actSync.OnUpdate := actSyncUpdate;

    FButtonSync := Services.AddToolButton(FToolbar.Name, 'btnSync', actSync) as TToolButton;
    FButtonSync.Style := tbsButton;


    actBranch := TAction.Create(FToolbar);
    actBranch.Caption := '(branch name)';
    actBranch.Enabled := True;
    actBranch.ImageIndex := FImgUnknown;
    actBranch.OnExecute := actBranchExecute;
    actBranch.OnUpdate := actBranchUpdate;

    FButtonBranch := Services.AddToolButton(FToolbar.Name, 'btnBranch', actBranch) as TToolButton;
    FButtonBranch.Style := tbsTextButton;
    FButtonBranch.DropdownMenu := TPopupMenu.Create(FButtonBranch);
    FButtonBranch.DropdownMenu.AutoHotkeys := maManual;
    FButtonBranch.DropdownMenu.OnPopup := actBranchMenuPopup;
    FButtonBranch.DropdownMenu.AutoPopup := True;


    FToolbar.Left := Application.MainForm.Width - FToolbar.Width;
    FToolbar.Visible := True;
//    Services.ReadToolbar(FToolbar.Owner, FToolbar.Parent, FToolbar.Name, TWinControl(FToolbar));
    Services.ToolbarModified(FToolbar);
  finally
    Services.MenuEndUpdate;
  end;
end {TVCSInfoWizard.Create};
{ ------------------------------------------------------------------------------------------------ }
destructor TVCSInfoWizard.Destroy;
var
  Services: INTAServices;
  Button: TToolButton;
begin
  Supports(ToolsAPI.BorlandIDEServices, INTAServices, Services);
//  Services.WriteToolbar(FToolbar);
//  FButtonIn.Action.Free;
  for Button in FToolbar do begin
    FToolbar.Perform(CM_CONTROLCHANGE, WPARAM(Button), 0);
  end;
  Services.MenuBeginUpdate;
  try
    Services.ToolbarModified(FToolbar);
    FToolbar.Free;
  finally
    Services.MenuEndUpdate;
  end;
  FRepos.Free;
  inherited;
end;

procedure TVCSInfoWizard.actBranchUpdate(Sender: TObject);
var
  actBranch: TAction;
  Repo: TRepoInfo;

  NewImageIndex: Integer;
  NewCaption: string;
  NewEnabled: boolean;
  Services: INTAServices;
begin
  actBranch := TAction(Sender);

  Repo := GetActiveFileRepo;
  NewEnabled := Repo.IsRepo;
  if Repo.IsRepo then begin
    NewCaption := Repo.Branch;
    case Repo.Pending of
      -1:   NewImageIndex := FImgUnknown;
       0:   NewImageIndex := FImgClean;

      else  NewImageIndex := FImgPending;
    end;

  end else begin
    NewImageIndex := -1; // FImgNeutral;
    if Repo.Root = '' then begin
      NewCaption := '(no project)';
    end else begin
      NewCaption := '(not Mercurial)';
    end;
  end;

  if (actBranch.ImageIndex <> NewImageIndex) or (actBranch.Caption <> NewCaption) or (actBranch.Enabled <> NewEnabled) then begin
    actBranch.Enabled := NewEnabled;
    actBranch.ImageIndex := NewImageIndex;
    actBranch.Caption := NewCaption;
    actBranch.Hint := actBranch.Caption;

    Supports(ToolsAPI.BorlandIDEServices, INTAServices, Services);
    Services.ToolbarModified(FToolbar);
    LogMessage(Format('actBranchUpdate: IsRepo=%d, In: %d, Out: %d; Caption="%s", Img=%d',

procedure TVCSInfoWizard.actBranchMenuClick(Sender: TObject);
var
  Item: TMenuItem;
  Repo: TRepoInfo;
  Output: string;
  MsgType: TMsgDlgType;
  ModuleServices: IOTAModuleServices;
  i: Integer;
begin
  Item := Sender as TMenuItem;
  Repo := GetActiveFileRepo;
  if Repo.IsRepo then begin
    Supports(ToolsAPI.BorlandIDEServices, IOTAModuleServices, ModuleServices);
    if not ModuleServices.SaveAll then
      Exit;

    {$MESSAGE WARN 'HINT: perhaps close the project?'}
    Output := '';
    if ExecuteCmd('hg -y update "' + Item.Caption + '"', Output, False, nil, Repo.Root) = 0 then begin
      TaskMessageDlg(Repo.Root, Output, mtInformation, [mbOK], 0);
    end else begin
      TaskMessageDlg(Repo.Root, Output, mtError, [mbOK], 0);
    end;
    {$MESSAGE WARN 'TODO: reopen the project if we closed it'}
    for i := ModuleServices.ModuleCount - 1 downto 0 do begin
      ModuleServices.Modules[i].Refresh(False);
    end;
  end;
end;

procedure TVCSInfoWizard.actBranchMenuPopup(Sender: TObject);
var
  Menu: TPopupMenu;
  Repo: TRepoInfo;
  Branches: TStringList;
  Branch: string;
  mi: TMenuItem;
begin
  Menu := Sender as TPopupMenu;
  Menu.Items.Clear;
  Repo := GetActiveFileRepo(True);
  if Repo.IsRepo then begin


    Branches := TStringList.Create;
    try
      ExecuteCmd('hg -yq branches', Branches.Append, False, nil, Repo.Root);
      Branches.Sort;
      for Branch in Branches do begin
        if Branch <> Repo.Branch then begin
          mi := TMenuItem.Create(Menu);
          mi.Caption := Branch;

          mi.OnClick := actBranchMenuClick;
          Menu.Items.Add(mi);
        end;
      end;
    finally
      Branches.Free;
    end;
  end;
end {TVCSInfoWizard.actBranchMenuPopup};

procedure TVCSInfoWizard.actSyncExecute(Sender: TObject);
begin
  Self.Execute;
end;

procedure TVCSInfoWizard.actSyncUpdate(Sender: TObject);
var
  actSync: TAction;
  Repo: TRepoInfo;
  NewImageIndex: Integer;
  NewCaption: string;
  NewEnabled: boolean;
  Services: INTAServices;
begin
  actSync := Sender as TAction;
  Repo := GetActiveFileRepo;
  NewEnabled := Repo.IsRepo;
  if Repo.IsRepo then begin
    if (Repo.Incoming < 0) and (Repo.Outgoing < 0) then begin
      NewImageIndex := FImgUnknown;
      NewCaption := 'Error while checking remote repository';
    end else if Repo.Incoming > 0 then begin
      if Repo.Outgoing > 0 then begin
        NewImageIndex := FImgInOut;
        NewCaption := Format('%d pull(s), %d push(es)', [Repo.Incoming, Repo.Outgoing]);
      end else begin
        NewImageIndex := FImgIn;
        NewCaption := Format('%d pull(s)', [Repo.Incoming]);
      end;

    end else if Repo.Outgoing > 0 then begin
      NewImageIndex := FImgOut;
      NewCaption := Format('%d push(es)', [Repo.Outgoing]);
    end else begin
      NewImageIndex := FImgNoSync;
      NewCaption := 'nothing to sync';
    end;

  end else begin
    NewImageIndex := FImgUnknown;
    NewCaption := '(not a repo)';
  end;

  if (NewImageIndex <> actSync.ImageIndex) or (NewCaption <> actSync.Caption) or (NewEnabled <> actSync.Enabled) then begin
    actSync.ImageIndex := NewImageIndex;
    actSync.Caption := NewCaption;
    actSync.Hint := actSync.Caption;
    actSync.Enabled := NewEnabled;

    Supports(ToolsAPI.BorlandIDEServices, INTAServices, Services);
    Services.ToolbarModified(FToolbar);
    LogMessage(Format('actSyncUpdate: IsRepo=%d, In: %d, Out: %d; Caption="%s", Img=%d',
                [Ord(Repo.IsRepo), Repo.Incoming, Repo.Outgoing, NewCaption, NewImageIndex]));
  end;
end {TVCSInfoWizard.actSyncUpdate};

{ ------------------------------------------------------------------------------------------------ }
function TVCSInfoWizard.GetMenuText: string;
var
  Project: IOTAProject;
  Repo: TRepoInfo;
begin

end;

function TVCSInfoWizard.GetActiveFileRepo(const AForceUpdate: Boolean): TRepoInfo;
var
  Modules: IOTAModuleServices;
  Module: IOTAModule;
  Editor: IOTAEditor;
  FileName: string;
begin

  if Supports(ToolsAPI.BorlandIDEServices, IOTAModuleServices, Modules) then begin

    Module := Modules.CurrentModule;
    if Assigned(Module) then begin

      Editor := Module.CurrentEditor;
      if Assigned(Editor) then
        FileName := Editor.FileName;
    end;
    if FileExists(FileName) then begin
      Result := GetRepoInfo(FileName, AForceUpdate);
    end else begin
      Result := GetProjectRepo(AForceUpdate);
    end;
  end else begin
    Result := Default(TRepoInfo);
  end;
end {TVCSInfoWizard.GetActiveFileRepo};

function TVCSInfoWizard.GetProjectRepo(const AForceUpdate: Boolean): TRepoInfo;
var
  Project: IOTAProject;
begin
  Project := ToolsAPI.GetActiveProject;

      RootPath := RootPath.Trim;
      FinalRootPath := GetFinalPathName(RootPath);
      if AForceUpdate or (not FRepos.TryGetValue(FinalRootPath, Result)) or (Now - Result.LastUpdated > 5 / SecsPerDay) then begin
        Result.Root := RootPath;
        Result.IsRepo := True;
        Lines := TStringList.Create;
        try
          Lines.Clear;
          iRes := ExecuteCmd('hg -yq branch', Lines.Append, False, nil, FilePath);
          if iRes = 0 then begin
            Result.Branch := Lines.Text.Trim;
          end;

          Lines.Clear;
          iRes := ExecuteCmd('hg -yq status', Lines.Append, False, nil, FilePath);
          if iRes = 0 then begin
            Result.Pending := Lines.Count;
          end else begin
            Result.Pending := -1;
          end;

          Lines.Clear;
          iRes := ExecuteCmd('hg -yq incoming --newest-first --template "{rev}\t{node|short}\t{node}\t{parents}\t{date|isodatesec}\t{author}\t{branches}\t{desc|firstline}\t{tags}\n"',
                             Lines.Append, False, nil, FilePath);
          if iRes < 255 then begin
            Result.Incoming := Lines.Count;
          end else begin
            Result.Incoming := -1;
          end;

          Lines.Clear;
          iRes := ExecuteCmd('hg -yq outgoing --newest-first --template "{rev}\t{node}\t{parents}\t{date|isodatesec}\t{author}\t{branches}\t{desc|firstline}\t{tags}.\n"',
                             Lines.Append, False, nil, FilePath);
          if iRes < 255 then begin
            Result.Outgoing := Lines.Count;
          end else begin
            Result.Outgoing := -1;
          end;
        finally
          Lines.Free;
        end;
        Result.LastUpdated := Now;
      end;
    end;