AssistantProgram.pas

{**
@Abstract Assistant main class
@Author Prof1983 <prof1983@ya.ru>
@Created 14.07.2007
@LastMod 23.11.2012
}
unit AssistantProgram;

interface

uses
  IniFiles, SysUtils,
  ABase, AConsts2, ALogFileText, AMessageEvent, AMessageEventX, AProgramImpl, ASystemData, ATypes,
  AiChatAgentImpl, AiConsts, AiCoreImpl, AiInterpretatorImpl, AiReasonAgentImpl, AiReasonerModule,
  ArMessages,
  AilTokenizer,
  AssistantEngine, AssistantEnviromentObj, AssistantGlobals, AssistantModule, AssistantReason,
  AssistantSystem, ModuleInfoRec;

type //** Ãëàâíûé êëàññ ïðîãðàììû Assistant
  TAssistantProgram = class(TAProgram)
  private
    {** Ïðîâåðÿåì íàëè÷èå íåîáõîäèìûõ ôðåéìîâ â ÁÇ }
    procedure CheckKB();
    {** Ñîçäàåì èíòåðïðåòàòîð êîäà }
    procedure CreateInterpretator();
    {** Èíèöèàëèçèðóåì èñòî÷íèê çíàíèé }
    //procedure CreateKnowlegeBase();
    {** Ñîçäàåì ãëàâíîãî àãàíòà ðåàëèçàöèè ðàçóìà }
    procedure CreateReasonAgent();
    {** Èíèöèàëèçèðîâàòü àãåíò ChatAgent }
    procedure InitChatAgent();
    {** Èíèöèàëèçèðîâàòü çàïèñü ëîã-ñîîáùåíèé â ôàéë }
    procedure InitLog();
    {** Ñîçäàåì ìîäóëü ëîãè÷åñêîãî âûâîäà íà îñíîâå îíòîëîãèè OWL }
    procedure InitReasoner();
  protected
    {** Ñðàáàòûâàåò ïðè ñîçäàíèè îáúåêòà }
    procedure DoCreate(); override;
    {** Ñðàáàòûâàåò ïðè óíè÷òîæåíèè îáúåêòà }
    procedure DoDestroy(); override;
    function DoInitialize(): AError; override;
    {** Ñðàáûòûâàåò ïåðåä çàïóñêîì ïîäïðîöåññà }
    function DoStart(): WordBool; override;
    {** Ñðàáàòûâàåò ïîñëå óäà÷íîãî çàïóñêà ïðîãðàììà (ñåðâèñà) }
    function DoStarted(): WordBool; override;
  public
    function GetModuleByIndex(Index: Integer): TAssistantModule;
    function GetModuleByLocalId(LocalId: Integer): TAssistantModule;
    function GetModuleCount(): Integer;
    function GetSendMessageEvent(): TProfMessageEvent;
  public
    //function AddMessage(const AMsg: WideString): AInt; override;
    {** Âûïîëíèòü èëè ïåðåäàòü äî÷åðíèì îáúåêòàì }
    function AddMessageA(Msg: AMessage): Integer; virtual;
    {** Äîáàâèòü DLL ìîäóëü }
    function AddModule(Module: TAssistantModule): Integer;
    function NewModule(FileName: WideString): TAssistantModule;
  public
    {** Îòïðàâèòü ñîîáùåíèå ðîäèòåëüñêîìó îáúåêòó ÷åðåç OnMessage }
    function SendMessage(const Msg: WideString): Integer; override;
    {** Îòïðàâèòü ñîîáùåíèå ðîäèòåëüñêîìó îáúåêòó ÷åðåç OnMessageA }
    function SendMessageA(Msg: AMessage): Integer; virtual;
    {** Îòïðàâëÿåò ñîîáùåíèå ðîäèòåëüñêîìó îáúåêòó ÷åðåç OnMessage }
    function SendStrMessage(const Msg: WideString): Integer;
  public
    {** Çàãðóçèòü DLL ìîäóëè }
    procedure LoadModules();
    {** Âûïîëíèòü ñêðèïò }
    function RunScript(Code: WideString): Boolean;
    {** Âûïîëíèòü ñèñòåìíûé ìåòîä }
    function RunSystemMethod(ClassName, MethodName, Param: WideString): Boolean;
  public
    {** Îñâîáîæäàåò âñå èíèöèàëèçèðîâàííûå îáúåêòû }
    function Finalize(): AError; override;
    {** Èíèöèàëèçèðóåò âñå íåîáõîäèìûå îáúåêòû }
    function Initialize(): AError; override;
  public
    class function GetInstance(): TAssistantProgram;
  public
    constructor Create();
  public
    (*
    property LogFileName: WideString read FLogFileName write FLogFileName;
    {** Ñòåê ñîîáùåíèé äëÿ ìîäóëÿ }
    property Messages: TArMessages read FMessages;
    {** CallBack ôóíêöèÿ ïåðåäà÷è ñîîáùåíèÿ }
    property OnMessageA: TProcMessageA read FOnMessageA write FOnMessageA;
    *)
    property SendMessageEvent: TProfMessageEvent read GetSendMessageEvent;
    //** Êîëëè÷åñòâî DLL ìîäóëåé
    property ModuleCount: Integer read GetModuleCount;
    //** DLL ìîäóëè ïî èíäåêñó
    property ModuleByIndex[Index: Integer]: TAssistantModule read GetModuleByIndex;
    //** DLL ìîäóëè ïî ID
    property ModuleByLocalID[LocalID: Integer]: TAssistantModule read GetModuleByLocalID;
  end;

{** Âîçâðàùàåò ìèêðîÿäðî ñèñòåìû }
function AssistantProgram_GetCore(): TAiCore;
{** Èíèöèàëèçèðóåò ïðîãðàììó }
function AssistantProgram_Initialize(): AError;

resourcestring // Ñîîáùåíèÿ ----------------------------------------------------
  stInitializeConnectionError = 'Ñîåäèíåíèå ñ ÿäðîì íå èíèöèàëèçèðîâàíî';
  stInitializeConnectionOk = 'Ñîåäèíåíèå ñ ÿäðîì èíèöèàëèçèðîâàíî';
  stInitializeConnectionStart = 'Èíèöèàëèçàöèÿ ñîåäèíåíèÿ ñ ÿäðîì';
  stInitializeEventsError = 'Ñîáûòèÿ íå èíèöèàëèçèðîâàíû';
  stInitializeEventsOk = 'Ñîáûòèÿ èíèöèàëèçèðîâàíû';
  stInitializeEventsStart = 'Èíèöèàëèçàöèÿ ñîáûòèé';
resourcestring
  INIT_KNOWLEGE_BASE = 'Èíèöèàëèçèðóåì èñòî÷íèê çíàíèé';
  INIT_REASON_AGENT = 'Ñîçäàåì ãëàâíîãî àãåíòà ðåàëèçàöèè ðàçóìà';
  INIT_SETTINGS = 'Ñîçäàåì îáúåêò ðàáîòû ñ íàñòðîéêàìè ïðîãðàììû';
resourcestring
  NoModulesMessage = 'Íå íàéäåíî íè îäíîãî ìîäóëÿ.'#13#10+
        'Ïðîâåðüòå íàñòðîéêè ïðîãðàììû, ïðîâåðüòå íàëè÷èå DLL ìîäóëåé '+
        '(îáû÷íî DLL ìîäóëè ðàñïîëàãàþòñÿ â ïàïêå modules).'#13#10+
        'Äîïîëíèòåëüíóþ èíôîðìàöèþ ñìîòðèòå â äîêóìåíòàöèè è íà ñàéòå aikernel.org';
  IniFileDefault =
    '; Ôàéë íàñòðîåê assistant.ini äëÿ ñèñòåìû Assistant'#13#10+
    '; Prof1983 <prof1983@ya.ru>'#13#10+
    #13#10+
    '; Ñåêöèÿ ñ îñíîâíûìè íàñòðîéêàìè'#13#10+
    '[General]'#13#10+
    '; Èìÿ ôàéëà ìîäóëÿ-çàãðóç÷èêà'#13#10+
    'BootModule = ' + BootModuleDefaultFileName + #13#10 +
    #13#10;

implementation

uses
  fStart;

var
  {** Ìèêðîÿäðî ñèñòåìû }
  FCore: TAiCore;
  FLogFileName: WideString;
  FMessages: TArMessages;
  {** CallBack ôóíêöèÿ ïåðåäà÷è ñîîáùåíèÿ }
  FOnMessageA: TProcMessageA;
  FSendMessageEvent: TProfMessageEvent;
  FSendMessageEventX: TProfMessageEventX;
  {** Àãåíò ÷àò-áîò }
  FChatAgent: TAiChatAgent;
  {** Èíòåðïðåòàòîð êîäà íà ÿçûêå AR }
  FInterpretator: TAiInterpretator;
  {** Ãëàâíûé îáúåêò ðåàëèçàöèè ðàçóìà }
  FReasonAgent: TAiReasonAgent;
  {** Ìîäóëü ëîãè÷åñêîãî âûâîäà íà îñíîâå îíòîëîãèè OWL }
  FReasoner: TAiReasonerModule;
  {** Äâèæîê Assitant }
  FEngine: TAssistantEngine;
  {** DLL ìîäóëè ñèñòåìû }
  FModules: array of TAssistantModule;
  {** Ãëàâíûé àãåíò }
  FReason: TReason;
  {** Assistant system }
  FSystem: TAssistantSystem;

function SystemProc(Sender, Receiver, Cmd, Param1, Param2: Integer): Integer; stdcall;
var
  i: Integer;
  i2: Integer;
  p: TAssistantProgram;
begin
  p := TAssistantProgram.GetInstance();

  //MainForm.LogRichEdit.Lines.Add(IntToStr(Sender)+' '+IntToStr(Receiver)+' '+
  //  IntToStr(Cmd)+' '+IntToStr(Param1)+' '+IntToStr(Param2));

  if (Receiver = AssistantGlobals.MainModuleLoacalID) then
    case Cmd of
      AssistantGlobals.GetModuleListCount: // Param1 - óêàçàòåëü íà ïåðåìåííóþ Int32
        begin
          Integer(Pointer(Param1)^) := p.ModuleCount;
        end;
      AssistantGlobals.GetModuleList: // Param1 - óêàçàòåëü íà îáëàñòü ïàìÿòè array[0..count-1]; Param2 - count
        begin
          if p.ModuleCount > Param2 then
            i2 := Param2
          else
            i2 := p.ModuleCount;
          for i := 0 to i2 - 1 do
            Integer(Pointer(Param1 + i * 4)^) := p.ModuleByIndex[i].Handle;
        end;
      AssistantGlobals.GetModuleInfo: // Param1 - LocalID ìîäóëÿ, Param2 - PModuleInfo2
        begin
          p.ModuleByLocalID[Param1].ToModuleInfo2(TModuleInfo2(Pointer(Param2)^));
          // ...
        end;
    end;

  Result := 0;
end;

// --- Public ---

function AssistantProgram_GetCore(): TAiCore;
begin
  Result := FCore;
end;

function AssistantProgram_Initialize(): AError;
var
  IniFile: TIniFile;
  S: string;
  FileName: string;
  P: TAssistantProgram;
begin
  P := TAssistantProgram.GetInstance();

  TStartForm.AddToLog('Èíèöèàëèçàöèÿ...');
  FCore := TAiCore.Create();

  P.Initialize();

  FSystem := TAssistantSystem.Create();
  // Çàäàåì ïàðàìåòðû ïî óìîë÷àíèþ
  FSystem.BootModuleFileName := AssistantGlobals.BootModuleDefaultFileName;
  FSystem.ConfigurationDir := AssistantGlobals.ConfigurationDefaultDir; //'configuration';
  FSystem.ModulesDir := ModulesDefaultDir;

  S := ParamStr(1);
  if (S <> '') then
  begin
    FileName := S;
    S := ExtractFilePath(S);
    if (S = '') then
      FileName := FExePath + FileName;
  end;

  if (FileName = '') then
  begin
    FileName := FExePath + 'Assistant.ini';
    if not(FileExists(FileName)) then
      FileName := FConfigPath + 'Assistant.ini';
  end;

  if FileExists(FileName) then
  begin
    IniFile := TIniFile.Create(FileName);
    // ìîäóëü çàãðóç÷èê
    FSystem.BootModuleFileName := IniFile.ReadString('General', 'BootModule', FSystem.BootModuleFileName);
    // Äèðåêòîðèÿ êîíôèãóðàöèè
    FSystem.ConfigurationDir  := IniFile.ReadString('General', 'Configuration', FSystem.ConfigurationDir);
    IniFile.Free();
  end;

  TStartForm.AddToLog('Çàãðóçêà DLL ìîäóëåé...');
  // Çàãðóçèòü DLL ìîäóëè
  P.LoadModules();

  TStartForm.AddToLog('Èíèöèàëèçàöèÿ äâèæêà (Engine)');
  FEngine := TAssistantEngine.Create();
  FEngine.Initialize();

  TStartForm.AddToLog('Èíèöèàëèçàöèÿ ãëàâíîãî àãåíòà');
  FReason := TReason.Create();
  FEngine.Enviroment.AddComponent(FReason);

  // Íóæíî ðàñêîìåíòèðîâàòü, åñëè îáÿçàòåëüíî òðåáóåòñÿ çàïóñê ìîäóëåé.
  {if Length(FModules) = 0 then
  begin
    ShowMessage(NoModulesMessage);
    Halt(1);
  end;}
  Result := 0;
end;

{ TAssistantProgram }

(*function TAssistantProgram.AddMessage(const AMsg: WideString): Integer;
var
  x: AXmlNode;
  content: AXmlNode;
  i: Integer;
  m: WideString;
begin
  {SendMessage( //ACL_PREFIX + ACL + CRLF +
    ACL_SENDER + ':' + 'Core' + CRLF +
    ACL_CONTENT + ':' + '' + CRLF);}

  m := ARL_PREFIX + ARL + ' ' + ARL_ASSISTANT_FORM + ' ' + ARL_CORE + ' ' + ARL_CMD_CORE_GET_MODULES;

  if (AMsg = m) then
  begin
    X := AXmlNode_New0();
    AXmlNode_SetName(X, 'acl');
    //x.ChildNodes.New(ACL_SENDER).Value := ARL_CORE;
    //x.ChildNodes.New(ACL_RECEIVER).Value := ARL_ASSISTANT_FORM;
    //x.ChildNodes.New(ACL_PERFORMATIVE).Value := ACL_Ansswer;
    content := AXmlNode_GetChildNodeByName(X, ACL_CONTENT);
    //content.ChildNodes.New('Core');
    for i := 0 to FRuntime.ModuleCount - 1 do
      AXmlNode_GetChildNodeByName(X, FRuntime.GetModuleLocalNameByIndex(i));
    Result := Self.SendMessageX(X);
  end
  else
  begin
    //Result := FCore.AddMessage(AMsg);
  end;
end;*)

function TAssistantProgram.AddMessageA(Msg: AMessage): Integer;
begin
  Result := 0;
end;

function TAssistantProgram.AddModule(Module: TAssistantModule): Integer;
begin
  Result := Length(FModules);
  SetLength(FModules, Result + 1);
  FModules[Result] := Module;
end;

procedure TAssistantProgram.CheckKB();
var
  idAsistantClass: AId;  // ID êëàññà ïðîãðàììû ARAsistant
begin
  idAsistantClass := 0;
  // Ïðîâåðÿåì íàëè÷èå â ÁÇ çíàíèé î ïðîãðàììå ARAsistant
  if (idAsistantClass = 0) then
  begin
    // Ñîçäàåì êëàññ ïðîãðàììû ARAsistant
    idAsistantClass := FCore.KnowledgeBase.NewFrame();
  end;
  if idAsistantClass = 0 then
  begin
    AddToLog(lgDataBase, ltError, 'Ôðåéì êëàññà ïðîãðàììû ARAssitant íå ñîçäàí');
    Exit;
  end;
  // ...

  // Ïðîâåðÿåì íàëè÷èå â ÁÇ çíàíèé îá îêíå ïðîãðàììû ARAsistant
  // ...
end;

constructor TAssistantProgram.Create();
begin
  // -- Default settings --
  Self.FConfigDir := AiConfigDir;
  Self.FDataDir := AiDataDir;
  Self.FProgramDescription := 'Personal assistant';
  Self.FProgramName := 'Assistant';
  Self.FProgramNameDisplay := 'Assistant';
  Self.FProgramVersionStr := '0.0';
  Self.FSystemName := 'AReason';

  Self.FConfigDir := AiConfigDir;
  Self.FDataDir := AiDataDir;

  inherited Create();

  FSendMessageEvent := TProfMessageEvent.Create(0, 'SendMessage');
  FSendMessageEventX := TProfMessageEventX.Create(0, 'SendMessageX');

  // Ñîçäàòü êîíôèãóðàöèè ïðîãðàììû
  {if not(Assigned(FConfigDocument)) then
  try
    FConfigDocument := TConfigDocument.Create(Self.ExePath + AiConfigDir + PathDelim + Self.ProgramName + '.' + FILE_EXT_CONFIG, AddToLog);
  except
  end;}

  if not(Assigned(FMessages)) then
  try
    FMessages := TArMessages.Create();
  except
    FMessages := nil;
  end;
end;

(*procedure TAssistantProgram.CreateAsistantAgent();
begin
  // Ñîçäàåì àãåíòà Asistant
  FAssistantAgent := TAiAssistantAgent.Create();
  // Çàäàåì èíòåðïðåòàòîð
  FAssistantAgent.Interpretator := FInterpretator;
  // Çàäàåì êîä íà ÿçûêå AR
//  FAssistantAgent.CodeString := FKnowlegeBase.Frames.FreimStringByID[2];
  // Çàäàåì ôóíêöèþ äëÿ ëîãèðîâàíèÿ
  FAssistantAgent.OnAddToLog := AddToLog;
  // Çàäàåì ôóíêöèþ äëÿ âûâîäà ñîîáùåíèé
  FAssistantAgent.OnSendMessageToCore := Self.SendStrMessage;
  // Çàäàåì ôóíêöèþ äëÿ âûïîëíåíèÿ êîìàíä
//  FAsistantAgent.OnCommand := DoCommand;
  // Òåñò ïðîõîæäåíèÿ ñîîáùåíèé â ïðîãðàììå
  //FAsistantAgent.Ping('Òåñòîâîå ñîîáùåíèå');

  // TODO: Äîáàâëÿåì àãåíòà â ñïèñîê àãåíòîâ
  FCore.Agents.Add(FAssistantAgent);
  //FAgents.Add(FAsistantAgent);
end;*)

procedure TAssistantProgram.CreateInterpretator();
begin
  // Ñîçäàåì èíòåðïðåòàòîð êîäà
  FInterpretator := TAiInterpretator.Create();
  FInterpretator.OnAddToLog := AddToLog;
end;

procedure TAssistantProgram.CreateReasonAgent();
begin
  AddToLog(lgNone, ltInformation, INIT_REASON_AGENT);
  FReasonAgent := TAiReasonAgent.Create();
  // Çàëàåì ôóíêöèþ âûâîäà ëîã-ñîîáùåíèé
  FReasonAgent.OnAddToLog := AddToLog;
  // Çàäàåì ôóíêöèþ âûâîäà ñîîáùåíèé
  FReasonAgent.OnSendMessageToCore := SendStrMessage;
  // Çàäàåì ëîã-ïðåôèêñ
  FReasonAgent.LogPrefix := '  ';
  // Çàäàåì èñòî÷íèê çíàíèé
  FReasonAgent.Pool := FCore.KnowledgeBase;
  // Çàäàåì ID ôðåéìà ðàçóìà
//  FReasonAgent.ID := FSettings.ReasonID;
  // Èíèöèàëèçèðóåì ãëàâíûé îáúåêò
  FReasonAgent.Initialize();

  FCore.Agents.Add(FReasonAgent);
end;

procedure TAssistantProgram.DoCreate();
begin
  Self.FIsComServer := False;
  inherited DoCreate();
  // Ñîçäàåì ëîêàëüíîå ÿäðî ïðîãðàììû
  FCore := TAiCore.Create();
  IInterface(FCore)._AddRef();
  //FCore.OnSendMessage := Self.SendMessageEvent.Run;
  //FCore.OnSendMessageX := Self.SendMessageEventX.Run;
  //FCore.Initialize();

  // Ñîçäàåì ìîäóëü ëîãè÷åñêîãî âûâîäà íà îñíîâå îíòîëîãèè OWL
  InitReasoner();

  FReasoner := TAiReasonerModule.Create();
end;

procedure TAssistantProgram.DoDestroy();
begin
  if Assigned(FMessages) then
  try
    FMessages.Free();
  finally
    FMessages := nil;
  end;
  inherited DoDestroy();
end;

function TAssistantProgram.DoInitialize(): AError;
begin
  Result := inherited DoInitialize();
  InitLog();
  AddToLog(lgGeneral, ltInformation, '=');
  AddToLog(lgGeneral, ltInformation, 'Èíèöèàëèçàöèÿ ïðîãðàììû');
end;

function TAssistantProgram.DoStart(): WordBool;
begin
  // Íà÷èíàåì âûïîëíåíèå êîäà ãëàâíîãî àãåíòà ðåàëèçàöèè ðàçóìà
  FReasonAgent.Start();
end;

function TAssistantProgram.DoStarted(): WordBool;
begin
  AddToLog(lgGeneral, ltInformation, stInitializeConnectionStart);
  Result := inherited DoStarted();
end;

function TAssistantProgram.Finalize(): AError;
var
  Res: AError;
begin
  Res := inherited Finalize();

  if Assigned(FCore) then
  try
    try
      IInterface(FCore)._Release();
    finally
      FCore := nil;
    end;
  except
  end;

  if Assigned(FReasoner) then
  try
    try
      IINterface(FReasoner)._Release();
    finally
      FReasoner := nil;
    end;
  except
  end;

  if Assigned(FChatAgent) then
  try
    try
      IInterface(FChatAgent)._Release();
    finally
      FChatAgent := nil;
    end;
  except
  end;

  if Assigned(FInterpretator) then
  try
    try
      IInterface(FInterpretator)._Release();
    finally
      FInterpretator := nil;
    end;
  except
  end;

  if Assigned(FReasonAgent) then
  try
    try
      IInterface(FReasonAgent)._Release();
    finally
      FReasonAgent := nil;
    end;
  except
  end;

  if Assigned(FReasoner) then
  try
    try
      IInterface(FReasoner)._Release();
    finally
      FReasoner := nil;
    end;
  except
  end;

  Result := Res;
end;

class function TAssistantProgram.GetInstance(): TAssistantProgram;
begin
  Result := TAssistantProgram(inherited GetInstance());
end;

function TAssistantProgram.GetModuleByIndex(Index: Integer): TAssistantModule;
begin
  if (Index >= 0) and (Index < Length(FModules)) then
    Result := FModules[Index]
  else
    Result := nil;
end;

function TAssistantProgram.GetModuleByLocalID(LocalID: Integer): TAssistantModule;
var
  i: Integer;
begin
  Result := nil;
  for i := 0 to High(FModules) do
    if FModules[i].Handle = LocalID then
    begin
      Result := FModules[i];
      Exit;
    end;
end;

function TAssistantProgram.GetModuleCount(): Integer;
begin
  Result := Length(FModules);
end;

function TAssistantProgram.GetSendMessageEvent(): TProfMessageEvent;
begin
  Result := FSendMessageEvent;
end;

procedure TAssistantProgram.InitChatAgent();
begin
  FChatAgent := TAiChatAgent.Create();
  FChatAgent.Initialize();
  FChatAgent.OnSendMessageToCore := SendStrMessage;
  FChatAgent.OnAddToLog := AddToLog;
  FCore.Agents.Add(FChatAgent);
end;

function TAssistantProgram.Initialize(): AError;
begin
  Result := inherited Initialize();

  InitLog();

  // Èíèöèàëèçèðóåì èñòî÷íèê çíàíèé
  //CreateKnowlegeBase();
  // Ïðîâåðÿåì íàëè÷èå íåîáõîäèìûõ ôðåéìîâ â ÁÇ
  CheckKB();
  // Ñîçäàåì èíòåðïðåòàòîð êîäà
  CreateInterpretator();

  // Ñîçäàåì ãëàâíûé àãåíò ðåàëèçàöèè ðàçóìà
  CreateReasonAgent();

  // Èíèöèàëèçèðóåì àãåíòà ÷àò-áîò
  InitChatAgent();

  AddToLog(lgNone, ltInformation, '-');

  //FCore.OnSendMessage := SendMessage;
  //FCore.OnSendMessageX := SendMessageX;
end;

procedure TAssistantProgram.InitLog();
var
  Log: TALogFileText;
begin
  if (FLogFileName = '') then
    FLogFileName := FExePath + AiLogDir + PathDelim + Self.ProgramName + '.' + FILE_EXT_LOG;
  Log := TALogFileText.Create();
  Log.FileName := FLogFileName;
  Log.Initialize();
  FLogDocuments.Add(Log.GetSelf());
end;

procedure TAssistantProgram.InitReasoner();
begin
  FReasoner := TAiReasonerModule.Create();
  FReasoner.Initialize();
  //FCore.AddModule(FReasoner);
end;

procedure TAssistantProgram.LoadModules();
var
  sr: TSearchRec;
  i: Integer;
  path: string;
  ModuleInfo: TModuleInfo;
begin
  try
    path := FExePath;
    i := FindFirst(path + FSystem.ModulesDir + '\*.dll', faAnyFile, sr);
    while (i = 0) do
    begin
      //LogRichEdit.Lines.Add('Íàéäåí ôàéë ' + sr.Name);

      try
        if (TAssistantModule.CheckModule(path + FSystem.ModulesDir + '\' + sr.Name, ModuleInfo) = 0) then
        begin
          //LogRichEdit.Lines.Add('Íàéäåí ìîäóëü ' + ModuleInfo.ModuleFullName);
          NewModule(path + FSystem.ModulesDir + '\' + sr.Name);
        end;
      except
        //LogRichEdit.Lines.Add('Îøèáêà ïðè çàãðóçêå DLL ìîäóëÿ ' + sr.Name);
      end;

      i := FindNext(sr);
    end;
    SysUtils.FindClose(sr);

    // Èíèöèàëèçàöèÿ âñåõ ìîäóëåé
    for i := 0 to High(FModules) do
      FModules[i].InitializeModule(FModules[i].Handle, SystemProc);

    // Çàïóñê âñåõ ìîäóëåé
    for i := 0 to High(FModules) do
      FModules[i].RunModule();
  except
    //LogRichEdit.Lines.Add('Îøèáêà ïðè çàãðóçêå DLL ìîäóëåé');
  end;
end;

function TAssistantProgram.NewModule(FileName: WideString): TAssistantModule;
begin
  Result := TAssistantModule.Create(FileName);
  AddModule(Result);
end;

function TAssistantProgram.RunScript(Code: WideString): Boolean;
var
  Tokenizer: TTokenizer;
  Token: WideChar;
  FPath: WideString;
  FMethodName: WideString;
  FParam: WideString;
begin
  Result := False;

  Tokenizer := TTokenizer.Create();
  Tokenizer.InputString := Code;
  //Tokenizer.Parse(Code);

  //FType := 0;
  FPath := '';
  FMethodName := '';
  FParam := '';
  while not(Tokenizer.Eof()) do
  begin
    Token := Tokenizer.NextChar();
    case Tokenizer.TokenType of
      CLASS_NAME_TOKEN_TYPE: // Êëàññ
        begin
          if Token = POINT_TOKEN then
          begin
            Tokenizer.AheadTokenType(METHOD_NAME_TOKEN_TYPE);
          end
          else
            FPath := FPath + Token;
        end;
      METHOD_NAME_TOKEN_TYPE: // Ìåòîä
        begin
          if Token = '(' then
          begin
            Tokenizer.AheadTokenType(PARAM_TOKEN_TYPE);
          end
          else
            FMethodName := FMethodName + Token;
        end;
      PARAM_TOKEN_TYPE: // îáëàñòü ïàðàìåòðîâ ìåòîäà
        begin
          if Token = '"' then
          begin
            Tokenizer.AheadTokenType(STRING_PARAM_TOKEN_TYPE);
          end
          else if Token = ')' then
          begin
            if (Tokenizer.NextChar() = ';') then
              Result := RunSystemMethod(FPath, FMethodName, FParam);
            //Tokenizer.BackTokenType();
          end;     
        end;
      STRING_PARAM_TOKEN_TYPE:
        begin
          if Token = '"' then
          begin
            Tokenizer.BackTokenType();
          end
          else
            FParam := FParam + Token;
        end;
    end;
  end;

  Tokenizer.Free();
end;

function TAssistantProgram.RunSystemMethod(ClassName, MethodName, Param: WideString): Boolean;
begin
  Result := False;

  if (ClassName = 'LogJournal') then
  begin
    if (MethodName = 'AddToLog') then
    begin
      if Assigned(LogJournal) then
        LogJournal.AddToLog(Param);
      Result := True;
    end;
  end;
end;

function TAssistantProgram.SendMessage(const Msg: WideString): Integer;
begin
  Result := inherited SendMessage(Msg);
  FSendMessageEvent.Run(Msg);
end;

function TAssistantProgram.SendMessageA(Msg: AMessage): Integer;
begin
  Result := 0;
  if Assigned(FOnMessageA) then
  try
    Result := FOnMessageA(Msg);
  except
  end;
end;

function TAssistantProgram.SendStrMessage(const Msg: WideString): Integer;
begin
  Result := FSendMessageEvent.Run(Msg);
end;

end.