unit SUBaseScanner;

interface
  uses
    System.Generics.Collections, SUBaseObject, SUBaseFilter;

  Type
    PBaseClilocFilter = class
      private
        m_ClilocID : Cardinal;
        m_State    : Boolean;
      public
        function Compare(Properties:PBaseProperty):Boolean;
        Constructor Create;

        class function Generate(SClilocID:Cardinal;SState:Boolean):PBaseClilocFilter;

        property ClilocID : Cardinal  read m_ClilocID write m_ClilocID;
        property State    : Boolean   read m_State    write m_State;
    end;

    PBasePropertyFilter = class
      private
        m_ClilocID    : Cardinal;
        m_Param       : Integer;
        m_ReqValue    : Integer;
        m_Comperator  : String;
      public
        function Compare(Properties:PBaseProperty):Boolean;
        Constructor Create;

        class function Generate(SClilocID:Cardinal;SParam,SValue:Integer;SComperator:String):PBasePropertyFilter;

        property ClilocID   : Cardinal  read m_ClilocID   write m_ClilocID;
        property Param      : Integer   read m_Param      write m_Param;
        property ReqValue   : Integer   read m_ReqValue   write m_ReqValue;
        property Comperator : String    read m_Comperator write m_Comperator;
    end;

    PBaseTextFilter = class
      private
        m_ClilocID : Cardinal;
        m_Param    : Integer;
        m_ReqValue : String;
        m_Explizit : Integer;
      public
        function Compare(Properties:PBaseProperty):Boolean;
        Constructor Create;

        class function Generate(SClilocID: Cardinal; SParam:Integer;SValue:String;SExplit: Integer): PBaseTextFilter;

        property ClilocID   : Cardinal  read m_ClilocID   write m_ClilocID;
        property Param      : Integer   read m_Param      write m_Param;
        property ReqValue   : String    read m_ReqValue   write m_ReqValue;
        property Explizit   : Integer   read m_Explizit   write m_Explizit;

    end;

    PBaseFilterEngine = class
      private
        m_ClilocFilter        : TList<PBaseClilocFilter>;
        m_BasePropertyFilter  : TList<PBasePropertyFilter>;
        m_BaseTextFilter      : TList<PBaseTextFilter>;
      public
        function Analyse(Obj:PBaseObject):Boolean;
        Constructor Create;

        property ClilocFilter        : TList<PBaseClilocFilter>    read m_ClilocFilter        write m_ClilocFilter;
        property BasePropertyFilter  : TList<PBasePropertyFilter>  read m_BasePropertyFilter  write m_BasePropertyFilter;
        property BaseTextFilter      : TList<PBaseTextFilter>      read m_BaseTextFilter      write m_BaseTextFilter;

    end;  
  
    PBaseScanner = class
      private
        m_Distance          : Cardinal;
        m_Vertical          : Cardinal;
        m_Nullpoint         : Boolean;
        m_ReadSub           : Boolean;
        m_Results           : TList<PBaseObject>;
        m_Ignored           : TList<PBaseObject>;
        m_TypeList          : TList<Word>;
        m_ColorList         : TList<Word>;
        m_FilterList        : TList<PBaseFilterEngine>;
        m_LocationList      : TList<Cardinal>;
        m_FindItem          : PBaseObject;
        m_FindCount         : Integer;
        m_FindQuantity      : Integer;
        m_FindFullQuantity  : Integer;
      public
        Constructor Create();

        procedure Scan(); virtual;

        property Distance           : Cardinal                  read m_Distance     write m_Distance;
        property Vertical           : Cardinal                  read m_Vertical     write m_Vertical;
        property UseNullPoint       : Boolean                   read m_Nullpoint    write m_Nullpoint;
        property Results            : TList<PBaseObject>        read m_Results;
        property Ignored            : TList<PBaseObject>        read m_Ignored;
        property TypeList           : TList<Word>               read m_TypeList     write m_TypeList;
        property ColorList          : TList<Word>               read m_ColorList    write m_ColorList;
        property FilterList         : TList<PBaseFilterEngine>  read m_FilterList   write m_FilterList;
        property LocationList       : TList<Cardinal>           read m_LocationList write m_LocationList;
        property ReadSubContainer   : Boolean                   read m_ReadSub      write m_ReadSub;
        property FindItem           : PBaseObject               read m_FindItem;
        property FindCount          : Integer                   read m_FindCount;
        property FindQuantity       : Integer                   read m_FindQuantity;
        property FindFullQuantity   : Integer                   read m_FindFullQuantity;
    end;

    {PBaseMapScanner = class
        //function FindAtCoord(X, Y : Word) : Cardinal;
    end;

    PBaseNotorietyScanner = class
      //function FindNotoriety(ObjType : Word; Notoriety : Byte) : Cardinal;

    end; }

implementation
  uses
    SUStealth, SysUtils;

{ PBaseFilterEngine }

function PBaseFilterEngine.Analyse(Obj: PBaseObject): Boolean;
var
  ergebnis : Boolean;
  i        : Integer;
begin
  ergebnis := True;

  if(ergebnis)then
  begin
    for i := 0 to (m_ClilocFilter.Count - 1) do
    begin
      if(ergebnis) then ergebnis := m_ClilocFilter[i].Compare(Obj.Properties);
    end;
  end;
  if(ergebnis)then
  begin
    for i := 0 to (m_BasePropertyFilter.Count - 1) do
    begin
      if(ergebnis) then ergebnis := m_BasePropertyFilter[i].Compare(Obj.Properties);
    end;
  end;
  if(ergebnis)then
  begin
    for i := 0 to (m_BaseTextFilter.Count - 1) do
    begin
      if(ergebnis) then ergebnis := m_BaseTextFilter[i].Compare(Obj.Properties);
    end;
  end;

  Result := ergebnis;
end;

constructor PBaseFilterEngine.Create;
begin
  m_ClilocFilter := TList<PBaseClilocFilter>.Create;
  m_BasePropertyFilter := TList<PBasePropertyFilter>.Create;
  m_BaseTextFilter := TList<PBaseTextFilter>.Create;
end;

{ PBaseClilocFilter }

function PBaseClilocFilter.Compare(Properties: PBaseProperty): Boolean;
begin
  Result := (Properties.Contains(ClilocID) = State);
end;

constructor PBaseClilocFilter.Create;
begin
  m_ClilocID := 0;
  m_State := False;
end;

class function PBaseClilocFilter.Generate(SClilocID: Cardinal; SState: Boolean): PBaseClilocFilter;
begin
  Result := PBaseClilocFilter.Create;
  Result.ClilocID := SClilocID;
  Result.State := SState;
end;

{ PBasePropertyFilter }

function PBasePropertyFilter.Compare(Properties: PBaseProperty): Boolean;
var
  P     : TList<String>;
  val   : Variant;
  rval  : Integer;
begin
  Result := False;

  if(Properties.Contains(ClilocID))then
  begin
    P := Properties.GetParams(ClilocID);
    if(Param < P.Count) and ( Param > -1)then
    begin
      val := P[Param];
      try
        rval := val;
      except
        exit;
      end;
      if(Comperator = '>')then
      begin
        Result := rval > ReqValue;
      end else if(Comperator = '>=')then
      begin
        Result := rval >= ReqValue;
      end else if(Comperator = '=')then
      begin
        Result := rval = ReqValue;
      end else if(Comperator = '<>')then
      begin
        Result := rval <> ReqValue;
      end else if(Comperator = '<=')then
      begin
        Result := rval <= ReqValue;
      end else if(Comperator = '<')then
      begin
        Result := rval < ReqValue;
      end;
    end;
  end;
end;

constructor PBasePropertyFilter.Create;
begin
  m_ClilocID := 0;
  m_Param := 0;
  m_ReqValue := 0;
  m_Comperator := '=';
end;

class function PBasePropertyFilter.Generate(SClilocID: Cardinal; SParam, SValue: Integer; SComperator: String): PBasePropertyFilter;
begin
  Result := PBasePropertyFilter.Create();
  Result.ClilocID := SClilocID;
  Result.Param := SParam;
  Result.ReqValue := SValue;
  Result.Comperator := SComperator;
end;

{ PBaseTextFilter }

function PBaseTextFilter.Compare(Properties: PBaseProperty): Boolean;
var
  P     : TList<String>;
  val   : String;
begin
  Result := False;
  if(Properties.Contains(ClilocID))then
  begin
    P := Properties.GetParams(ClilocID);
    if(Param < P.Count) and ( Param > -1)then
    begin
      val := P[Param];
      if(Explizit = -2)then
      begin
        Result := UpperCase(val) = UpperCase(ReqValue);
      end else if(Explizit = -1)then
      begin
        Result := val = ReqValue;
      end else if(Explizit = 1)then
      begin
        Result := Pos(val,ReqValue,0)> 0;
      end else if(Explizit = 2)then
      begin
        Result := Pos(UpperCase(val),UpperCase(ReqValue),0)> 0;
      end;
    end;
  end;
end;

constructor PBaseTextFilter.Create;
begin
  m_ClilocID := 0;
  m_Param := 0;
  m_ReqValue := '';
  m_Explizit := 0;
end;

class function PBaseTextFilter.Generate(SClilocID: Cardinal; SParam:Integer;SValue:String;SExplit: Integer): PBaseTextFilter;
begin
  Result := PBaseTextFilter.Create();
  Result.ClilocID := SClilocID;
  Result.Param := SParam;
  Result.ReqValue := SValue;
  Result.Explizit := SExplit;
end;

{ PBaseScanner }

constructor PBaseScanner.Create;
begin
  m_Distance := 0;
  m_Vertical := 0;
  m_Nullpoint := True;
  m_Results := TList<PBaseObject>.Create;
  m_TypeList := TList<Word>.Create;
  m_ColorList := TList<Word>.Create;
  m_LocationList := TList<Cardinal>.Create;
  m_FilterList := TList<PBaseFilterEngine>.Create;
  m_Ignored := TList<PBaseObject>.Create;
  m_FindItem := PBaseObject.Create(0);
  m_ReadSub := False;
  m_FindCount := 0;
  m_FindQuantity := 0;
  m_FindFullQuantity := 0;
end;

procedure PBaseScanner.Scan;
var
  objectlist : TArray<Cardinal>;
  Serial     : Cardinal;
  Obj        : PBaseObject;
  Filter     : PBaseFilterEngine;
  ergebnis   : Boolean;
  Count    : Integer;
begin
  Results.Clear();
  Ignored.Clear();
  m_FindItem := PBaseObject.Create(0);
  m_FindCount := 0;
  m_FindQuantity := 0;
  m_FindFullQuantity := 0;
  if(TypeList.Count > 0) and ( ColorList.Count>0) and (LocationList.Count>0)then
  begin
    Script.FindEngine.FindTypesArrayEx(TypeList.ToArray(),ColorList.ToArray(),LocationList.ToArray(),ReadSubContainer);
    m_FindItem := PBaseObject.Create(Script.FindEngine.FindItem);
    objectlist := Script.FindEngine.GetFindedList();
    m_FindCount := Script.FindEngine.FindCount;
    m_FindQuantity := Script.FindEngine.FindQuantity;
    m_FindFullQuantity := Script.FindEngine.FindFullQuantity;
    if(objectlist <> nil)then
    begin
      for Serial in objectlist do
      begin
        Obj := PBaseObject.Create(Serial);
        Count := 0;
        for filter in FilterList do
        begin
          if(Count = 0)then
          begin
            ergebnis := filter.Analyse(Obj);
            if (ergebnis) then Inc(Count);
          end;
        end;
        if(Count>0)then
        begin
          if(Results.Count = 0) then m_FindItem := Obj;
          Results.Add(Obj);
        end else begin
          Ignored.Add(Obj);
        end;
      end;
    end;
  end;
end;

end.