unit tpPartTender;

interface

uses
  Classes, tpPeg, mPegFilter, tpPeg_GclDm, tpGatherGcl, tpPegGclGatherDm;

type
  // According to the OD Peg
  TtpPartTender = class
  private
    FInPegs: TList;
    FTotalPrice: Double;
    FRelaPegs: TList;
    FRelaTotalPrice: Double;

    FBeginPeg: string;
    FBeginPegNum: Double;
    FEndPeg: string;
    FEndPegNum: Double;

    FInPegData: TtpPeg_GclData;
    FInGclGatherData: TtpPegGclGatherData;
    FRelaPegData: TtpPeg_GclData;

    procedure ResetPegInfo(APegFilter: TPegFilter); overload;

    function GetPegsTotalPrice(APegs: TList): Double;
    procedure Calculate;
    procedure GatherInGclBills;

    procedure ExecuteFilter(APegs: TtpPegList);

    function GetInPeg(AIndex: Integer): TtpPegNode;
    function GetInPegCount: Integer;
    function GetRelaPeg(AIndex: Integer): TtpPegNode;
    function GetRelaPegCount: Integer;
  public
    constructor Create;
    destructor Destroy; override;

    procedure Clear;
    procedure FilterPegs(APegFilter: TPegFilter; APegs: TtpPegList); overload;
    procedure FilterPegs(ABeginPegNum, AEndPegNum: Double; APegs: TtpPegList); overload;

    property BeginPeg: string read FBeginPeg;
    property BeginPegNum: Double read FBeginPegNum;
    property EndPeg: string read FEndPeg;
    property EndPegNum: Double read FEndPegNum;

    property InPegCount: Integer read GetInPegCount;
    property InPeg[AIndex: Integer]: TtpPegNode read GetInPeg;
    property TotalPrice: Double read FTotalPrice;

    property RelaPegCount: Integer read GetRelaPegCount;
    property RelaPeg[AIndex: Integer]: TtpPegNode read GetRelaPeg;
    property RelaTotalPrice: Double read FRelaTotalPrice;

    property InPegData: TtpPeg_GclData read FInPegData;
    property InGclGatherData: TtpPegGclGatherData read FInGclGatherData;
    property RelaPegData: TtpPeg_GclData read FRelaPegData;
  end;

implementation

uses
  ZhAPI, tpGatherTree, UtilMethods;

{ TtpPartTender }

procedure TtpPartTender.Calculate;
begin
  FTotalPrice := GetPegsTotalPrice(FInPegs);
  FRelaTotalPrice := GetPegsTotalPrice(FRelaPegs);
end;

procedure TtpPartTender.Clear;
begin
  FInPegs.Clear;
  FRelaPegs.Clear;
end;

constructor TtpPartTender.Create;
begin
  FInPegs := TList.Create;
  FRelaPegs := TList.Create;
  FInPegData := TtpPeg_GclData.Create(nil);
  FInGclGatherData :=TtpPegGclGatherData.Create(nil);
  FRelaPegData := TtpPeg_GclData.Create(nil);
end;

destructor TtpPartTender.Destroy;
begin
  Clear;
  FRelaPegData.Free;
  FInGclGatherData.Free;
  FInPegData.Free;
  FRelaPegs.Free;
  FInPegs.Free;
  inherited;
end;

procedure TtpPartTender.FilterPegs(APegFilter: TPegFilter; APegs: TtpPegList);
begin
  ResetPegInfo(APegFilter);
  ExecuteFilter(APegs);
end;

procedure TtpPartTender.ExecuteFilter(APegs: TtpPegList);
var
  iPeg: Integer;
  vPegNode: TtpPegNode;
begin
  for iPeg := 0 to APegs.Count - 1 do
  begin
    vPegNode := APegs.Peg[iPeg];
    if vPegNode.IsPegIn(FBeginPegNum, FEndPegNum) then
      FInPegs.Add(vPegNode)
    else if vPegNode.IsPegRela(FBeginPegNum, FEndPegNum) then
      FRelaPegs.Add(vPegNode);
  end;
  Calculate;

  FInPegData.LoadData(FInPegs);
  FRelaPegData.LoadData(FRelaPegs);

  GatherInGclBills;
end;

procedure TtpPartTender.FilterPegs(ABeginPegNum, AEndPegNum: Double;
  APegs: TtpPegList);
begin
  Clear;
  FBeginPegNum := ABeginPegNum;
  FBeginPeg := Num2Peg(FBeginPegNum);
  FEndPegNum := AEndPegNum;
  FEndPeg := Num2Peg(FEndPegNum);
  ExecuteFilter(APegs);
end;

procedure TtpPartTender.GatherInGclBills;
var
  vGcls: TtpGatherGclList;
  iPeg, iGcl: Integer;
  vPeg: TtpPegNode;
begin
  vGcls := TtpGatherGclList.Create;
  try
    for iPeg := 0 to FInPegs.Count - 1 do
    begin
      vPeg := TtpPegNode(FInPegs.Items[iPeg]);
      for iGcl := 0 to vPeg.RelaGclNodes.Count - 1 do
        vGcls.GatherNode(TtpGatherTreeNode(vPeg.RelaGclNodes.Items[iGcl]), vPeg.RelaNode);
    end;
    FInGclGatherData.LoadGclGatherData(vGcls);
  finally
    vGcls.Free;
  end;
end;

function TtpPartTender.GetInPeg(AIndex: Integer): TtpPegNode;
begin
  Result := TtpPegNode(FInPegs.Items[AIndex]);
end;

function TtpPartTender.GetInPegCount: Integer;
begin
  Result := FInPegs.Count;
end;

function TtpPartTender.GetPegsTotalPrice(APegs: TList): Double;
var
  iPeg: Integer;
  vPeg: TtpPegNode;
begin
  Result := 0;
  for iPeg := 0 to APegs.Count - 1 do
  begin
    vPeg := TtpPegNode(APegs.Items[iPeg]);
    Result := Result + vPeg.RelaNode.TotalPrice;
  end;
end;

function TtpPartTender.GetRelaPeg(AIndex: Integer): TtpPegNode;
begin
  Result := TtpPegNode(FRelaPegs.Items[AIndex]);
end;

function TtpPartTender.GetRelaPegCount: Integer;
begin
  Result := FRelaPegs.Count;
end;

procedure TtpPartTender.ResetPegInfo(APegFilter: TPegFilter);
begin
  Clear;
  FBeginPeg := APegFilter.BeginPeg;
  FBeginPegNum := APegFilter.BeginPegNum;
  FEndPeg := APegFilter.EndPeg;
  FEndPegNum := APegFilter.EndPegNum;
end;

end.
