program Ernst_OLX_Editor_Caller;

{$M $1000,$0,$0 }   { 16K stack, no heap }

uses
    Crt, Dos, Ernst;

var
    Buffer        : string;       {Buffer tempor rio para leitura de arquivos}
    C             : byte;         {Contador tempor rio}
    F             : text;         {Arquivo Texto Tempor rio}
    hdr           : text;         {Arquivo HEADER.DAT}
    ori           : text;         {Arquivo ORIGINAL}
    rep           : text;         {Arquivo REPLY}
    head          : text;         {arquivo com o cabe‡alho}
    reeditflag    : boolean;      {Reedi‡„o de mensagem, Reeditflag = TRUE}
    newflag       : boolean;      {Mensagem nova, Neflag = TRUE}
    work          : string[38];   {Diret¢rio de trabalho}
    reply         : string[49];   {Arquivo REPLY, com PATH}
    original      : string[49];   {Arquivo ORIGINAL, com PATH}
    header        : string[49];   {Arquivo HEADER.DAT, com PATH}
    reg           : boolean;      {Flag de registro}

    SeuEditor     : string[50];   {do EOEC.CFG: Editor de textos}
    SeuEditorParam: string[50];   {do EOEC.CFG: Parƒmetros para o editor}
    SeuHeader     : string[50];   {do EOEC.CFG: Arquivo com HEADER}
    SeuLogo       : string[50];   {do EOEC.CFG: Arquivo com assinatura}
    SeuTaglines   : string[50];   {do EOEC.CFG: Arquivo com taglines}

    OMsgDate      : string[8];    {Mensagem original: Data}
    OMsgTime      : string[5];    {Mensagem original: Hora}
    OMsgPacket    : string[8];    {Mensagem original: Pacote onde foi encontrada}

    OMsgArea      : string[3];    {Mensagem original: N£mero da  rea}
    OMsgAreaName  : string[25];   {Mensagem original: Nome da  rea}

    OMsgFrom      : string[25];   {Mensagem original: From}
    OMsgFFrom     : string[25];   {Mensagem original: Primeiro nome do From}
    OMsgLFrom     : string[25];   {Mensagem original: Ultimo nome do From}

    OMsgTo        : string[25];   {Mensagem original: To}
    OMsgFTo       : string[25];   {Mensagem original: Primeiro nome do To}
    OMsgLTo       : string[25];   {Mensagem original: Ultimo nome do To}

    OMsgSubj      : string[25];   {Mensagem original: Subject}

    RMsgArea      : string[3];    {Mensagem reply: N£mero da  rea}
    RMsgAreaName  : string[25];   {Mensagem reply: Nome da  rea}

    RMsgFrom      : string[25];   {Mensagem reply: From}
    RMsgFFrom     : string[25];   {Mensagem reply: Primeiro nome do From}
    RMsgLFrom     : string[25];   {Mensagem reply: Ultimo nome do From}

    RMsgTo        : string[25];   {Mensagem reply: To}
    RMsgFTo       : string[25];   {Mensagem reply: Primeiro nome do To}
    RMsgLTo       : string[25];   {Mensagem reply: Ultimo nome do To}

    RMsgSubj      : string[25];   {Mensagem reply: Subject}


(* ---------------------------------------------------------------------- *)
procedure Logo;
    (* Logo de programado por Ernesto Baschny *)

begin

    HighVideo;
    writeln('EOEC v1.2á - Ernst OLX Editor Caller');
    LowVideo;
    writeln('(c) 1994,95 por Ernesto Baschny');
    writeln;

end; {Logo}

(* ---------------------------------------------------------------------- *)
procedure Verify_Param;
    (* Verifica os parƒmetros passados ao programa *)

begin

    if (paramstr(1) = '/?') or (paramstr(1) = '-?') or (paramstr(1) = '?') then
    begin
         writeln('Sintaxe: EOEC <EOEC.CFG> <REPLY>');
         writeln;
         writeln('<EOEC.CFG> ‚ um arquivo texto no formato:');
         writeln;
         writeln(' 1: ** EOEC 1.2 CONFIG FILE **');
         writeln(' 2: <TEXT-EDITOR>');
         writeln(' 3: <HEADER.TXT>');
         writeln(' 4: <SIGN.TXT>');
         writeln(' 5: <TAGS.DAT>');
         writeln;
         writeln(' A primeira linha ‚ necess ria e deve ser exatamente essa.');
         writeln(' A numera‡„o ‚ o n£mero de cada linha e n„o deve ser inclusa.');
         writeln;
         writeln('<REPLY> ‚ o arquivo de resposta passado pelo OLX');
         CursorOff;
         readkey;
         CursorOn;
         halt(1);
    end;

    if paramcount<>2 then
    begin
         writeln('Sintaxe: EOEC <EOEC.CFG> <REPLY>');
         CursorOff;
         readkey;
         CursorOn;
         halt(1);
    end;

    if not FileExists(GetPathName(paramstr(2))+'NUL') then
    begin
         writeln('N„o existe o diret¢rio ', GetPathName(paramstr(2)));
         CursorOff;
         readkey;
         CursorOn;
         halt(1);
    end;

end; {Verify_Param}

(* ---------------------------------------------------------------------- *)
procedure CfgRead;
    (* Lˆ configura‡„o do arquivo *)

var cfgfile : Text;   {arquivo de configura‡„o, parƒmetro 1}
    I       : Byte;   {contador para separar editor do parƒmetro}

begin

    assign(cfgfile, paramstr(1));
    reset(cfgfile);
    readln(cfgfile,Buffer);

        {verifica se ‚ arquivo correto}
    
    if Buffer <> '** EOEC 1.2 CONFIG FILE **' then
    begin
         textcolor(lightred);
         writeln('ERRO: O arquivo ', paramstr(1), ' n„o cont‚m a configura‡„o do EOEC');
         textcolor(lightgray);
         writeln;
         writeln('Este arquivo ‚ um arquivo texto no formato:');
         writeln;
         writeln(' 1: ** EOEC 1.2 CONFIG FILE **');
         writeln(' 2: <TEXT-EDITOR>');
         writeln(' 3: <HEADER.TXT>');
         writeln(' 4: <SIGN.TXT>');
         writeln(' 5: <TAGS.DAT>');
         writeln;
         writeln(' A primeira linha ‚ necess ria e deve ser exatamente essa.');
         writeln;
         writeln(' A numera‡„o ‚ o n£mero de cada linha e n„o deve ser inclusa.');
         CursorOff;
         readkey;
         CursorOn;
         halt(1);
    end;

        {linha 1, editor de textos. Separa editor de parƒmetro}

    readln(cfgfile, Buffer);
    I := 0;
    for C := Length(Buffer) downto 0 do
    begin
         if (C = 0) and (I = 0) then I := Length(Buffer)+1;
         if (C > 0) and (Copy(Buffer,C,1) = ' ') then I := C;
    end;

    SeuEditor := Copy(Buffer,1,I-1);
    SeuEditorParam := Copy(Buffer,I+1,Length(Buffer)-I);

    { debug procedures:
    writeln('SeuEditor: ',SeuEditor);
    writeln('SeuEditorParam: ',SeuEditorParam);
    writeln;
     end debug }
    
        {linhas restantes}

    readln(cfgfile, Buffer);
    SeuHeader := Upper(Buffer);
    readln(cfgfile, Buffer);
    SeuLogo := Upper(Buffer);
    readln(cfgfile, Buffer);
    SeuTaglines := Upper(Buffer);

        {se £ltima linha for REG, ‚ usu rio registrado}
    
    if not Eof(cfgfile) then
    begin
         readln(cfgfile,Buffer);
         if Buffer = 'REG' then reg := true else reg := false;
    end;     

        {verifica se existem os arquivo especificados}
    
    if not FileExists(SeuHeader) then
    begin
         textcolor(lightred);
         writeln('ERRO: N„o foi achado o arquivo com o header especificado como ' ,SeuHeader);
         textcolor(lightgray);
         writeln;
         writeln('Verifique a linha 3 do arquivo ',paramstr(1),'.');
         writeln;
         CursorOff;
         readkey;
         CursorOn;
         halt(1);
    end;
    
        {verifica se existem os arquivo especificados}
    
    if not FileExists(SeuLogo) then
    begin
         textcolor(lightred);
         writeln('ERRO: N„o foi achado o arquivo com sua assinatura especificado como ' ,SeuLogo);
         textcolor(lightgray);
         writeln;
         writeln('Verifique a linha 4 do arquivo ',paramstr(1),'.');
         writeln;
         CursorOff;
         readkey;
         CursorOn;
         halt(1);
    end;
    
        {verifica se existem os arquivo especificados}
    
    if not FileExists(SeuTaglines) then
    begin
         textcolor(lightred);
         writeln('ERRO: N„o foi achado o arquivo com TAGLINES especificado como ',SeuTaglines);
         textcolor(lightgray);
         writeln;
         writeln('Verifique a linha 5 do arquivo ',paramstr(1),'.');
         writeln;
         CursorOff;
         readkey;
         CursorOn;
         halt(1);
    end;

end; {CfgRead}


(* ---------------------------------------------------------------------- *)
procedure CreateVars;
    (* Cria as vari veis de acordo com os arquivos *)

begin

    reply    := GetFileName(paramstr(2));
    work     := GetPathName(paramstr(2));
    reply    := work + reply;
    original := work + 'ORIGINAL';
    header   := work + 'HEADER.DAT';
    
    reeditflag := False;
    newflag    := False;
    reg        := False;

end; {CreateVars}


(* ---------------------------------------------------------------------- *)
procedure WriteMacroLine(var DestFile: Text; Level: Byte; Line: String);
    (* Lˆ linha especificada e grava ela no arquivo DestFile, usando *)
    (* vari veis, se necess rio                                      *)

var TempLine : String;
    Macro    : String[10];
    I        : Byte;
    flag     : Boolean;

begin

     TempLine := '';
     Macro := '';
     I := 1;

     while I <= Length(Line) do
     begin
          if Line[I] <> '@' then TempLine := TempLine + Line[I];
          if Line[I] = '@' then
          begin
               flag := false;
               inc(I);

               while flag = false do
               begin
                    if (Line[I] <> '@') and (Line[I] <> ' ') then Macro := Macro + Line[I];
                    if (Line[I] = '@') or (Line[I] = ' ') then flag := true;
                    inc(I);
               end;

               dec(I);
               Macro := Upper(Macro);

               if level >= 1 then
               begin

                   if Macro = 'OPACKET' then TempLine := TempLine + Upper(OMsgPacket);
                   if Macro = 'OANAME' then TempLine := TempLine + OMsgAreaName;
                   if Macro = 'OANUMBER' then TempLine := TempLine + OMsgArea;
                   if Macro = 'ODATE' then TempLine := TempLine + OMsgDate;
                   if Macro = 'OTIME' then TempLine := TempLine + OMsgTime;
                   if Macro = 'OFROM' then TempLine := TempLine + Capitalize(OMsgFrom);
                   if Macro = 'OFFROM' then TempLine := TempLine + Capitalize(OMsgFFrom);
                   if Macro = 'OLFROM' then TempLine := TempLine + Capitalize(OMsgLFrom);
                   if Macro = 'OTO' then TempLine := TempLine + Capitalize(OMsgTo);
                   if Macro = 'OFTO' then TempLine := TempLine + Capitalize(OMsgFTo);
                   if Macro = 'OLTO' then TempLine := TempLine + Capitalize(OMsgLTo);
                   if Macro = 'OSUBJ' then TempLine := TempLine + OMsgSubj;

               end;

               if level >= 2 then
               begin

                   if Macro = 'RANAME' then TempLine := TempLine + RMsgAreaName;
                   if Macro = 'RANUMBER' then TempLine := TempLine + RMsgArea;
                   if Macro = 'RFROM' then TempLine := TempLine + Capitalize(RMsgFrom);
                   if Macro = 'RFFROM' then TempLine := TempLine + Capitalize(RMsgFFrom);
                   if Macro = 'RLFROM' then TempLine := TempLine + Capitalize(RMsgLFrom);
                   if Macro = 'RTO' then TempLine := TempLine + Capitalize(RMsgTo);
                   if Macro = 'RFTO' then TempLine := TempLine + Capitalize(RMsgFTo);
                   if Macro = 'RLTO' then TempLine := TempLine + Capitalize(RMsgLTo);
                   if Macro = 'RSUBJ' then TempLine := TempLine + RMsgSubj;
                   if Macro = 'CURDATE' then TempLine := TempLine + Current_Date;
                   if Macro = 'CURTIME' then TempLine := TempLine + Current_Time;
                   if Macro = 'CURDOW' then TempLine := TempLine + Current_DOW;

               end;

               if Macro = '' then TempLine := TempLine + '@';
               Macro := '';
               flag := false;

          end;
          inc(I);

     end;

     if I <= Length(Line) then
          TempLine := TempLine + Buffer[I];

     if Line <> '' then
         writeln(DestFile,TempLine)
     else
         writeln(DestFile);

end; {WriteMacroLine}

(* ---------------------------------------------------------------------- *)
function LimpaLinha (linha: string): string;
    (* LimpaLinha(l) tira ocorrencias de  l  do  tipo 'ENY>EB>' ficando  *)
    (* apenas com 'EB>'                                                  *)

var  temp, I, C, I2 : byte;
     pos : array[0..10] of byte;

begin

    temp   := 1;
    I2     := 0;
    C      := 1;
    I      := 1;
    pos[0] := 1;

        {tenta a cada 6 caracteres, ou at‚ chegar no fim da linha}

    while (I2 < 5) and (C < length(linha)) do

    begin

        inc(C);
        inc(I2);
        if linha[C]='>' then
        begin
            temp := C;
            inc(C);

            while (linha[C] = ' ') do
                inc(C);

            if linha[C] = '>' then
            begin
                pos[I] := temp + 1;
                C := temp + 1;
            end
            else
                pos[I] := C;

            I2 := 0;
            inc(I);
        end;

    end;

    LimpaLinha := copy(linha,pos[I-2],length(linha)-pos[I-2]+1);

end;  {LimpaLinha}


(* ---------------------------------------------------------------------- *)
procedure DoVars;
    (* produz as vari veis para uso no HEADER *)

begin

        {lˆ arquivo HEADER.DAT e guarda resultados}

    reset(hdr);
    readln(hdr,Buffer);
    
    if Buffer <> 'Reply Header File' then
    begin
         textcolor(lightred);
         writeln('ERRO: Problemas no arquivo HEADER.DAT do OLX.');
         writeln('Tente sair do OLX e entrar de novo.');
         textcolor(lightgray);
         CursorOff;
         readkey;
         CursorOn;
         halt(2);
    end;

    readln(hdr,RMsgFrom);                     {Reply message: From}
    RMsgFFrom := FirstName(RMsgFrom);         {First name of From}
    RMsgLFrom := LastName(RMsgFrom);          {Last name of From}

    readln(hdr,RMsgTo);                       {Reply message: To}
    RMsgFTo   := FirstName(RMsgTo);           {First name of To}
    RMsgLTo   := LastName(RMsgTo);            {Last name of To}

    readln(hdr,RMsgSubj);                     {Reply message: Subject}
    readln(hdr,RMsgArea);                     {Reply message: Area number}
    readln(hdr,RMsgAreaName);                 {Reply message: Area Name}

    close(hdr);

        {se for o caso, lˆ vari veis do ORIGINAL (header do OLX)}

    if (NewFlag <> true) and (Reeditflag <> true) then
    begin
         reset(ori);
         readln(ori);
         readln(ori, Buffer);
    
         OMsgPacket := Trim(Copy(Buffer,9,8));     {Pacote: 'STIBBS'}
    
         readln(ori, Buffer);
         OMsgDate   := Trim(Copy(Buffer,7,8));     {Data: 'DD-MM-AA'}
         OMsgTime   := Copy(Buffer,17,5);          {Hora: 'HH:MM'}
    
         readln(ori, Buffer);
         OMsgFrom   := Trim(Copy(Buffer,7,25));    {From: 'xxxxxxxx'}
         OMsgFFrom  := FirstName(OMsgFrom);        {First name of From}
         OMsgLFrom  := LastName(OMsgFrom);         {Last name of From}
    
         readln(ori, Buffer);
         OMsgTo     := Trim(Copy(Buffer,7,25));    {To: 'xxxxxxxxx'}
         OMsgFTo    := FirstName(OMsgTo);          {First name of To}
         OMsgLTo    := LastName(OMsgTo);           {Last name of To}
    
         readln(ori, Buffer);
         OMsgSubj   := Trim(Copy(Buffer,7,25));    {Subj: 'xxxxxxxxx'}
         OMsgArea   := Copy(Buffer,45,3);
    
         close(ori);
    
            {ajuste do nome da  rea}
    
         if Copy(OMsgArea,2,1) = ')' then OMsgArea := Copy(OMsgArea,1,1);
         if Copy(OMsgArea,3,1) = ')' then OMsgArea := Copy(OMsgArea,1,2);
    
         if Length(OMsgArea) = 1 then OMsgAreaName := Trim(FileString(ori,6,48,25));
         if Length(OMsgArea) = 2 then OMsgAreaName := Trim(FileString(ori,6,49,25));
         if Length(OMsgArea) = 3 then OMsgAreaName := Trim(FileString(ori,6,50,25));
    
    end;

end; {DoVars}


(* ---------------------------------------------------------------------- *)
procedure DoHeader;
    (* Coloca um HEADER na mensagem *)

begin

        {Recria o arquivo de resposta}
    
    Rewrite(rep);
    
        {Caso tenha havido mudan‡a de  rea da mensagem, inclui essa informa‡„o}
    
    if (RMsgArea <> OMsgArea) then
    begin
         writeln(rep,' ú úúúùù--ÄÄÄÄÄÄ- Resposta a mensagem original em ',OMsgAreaName,' (',OMsgArea,')');
         writeln(rep);
    end;
    
    { if (Upper(OMsgTo) = Upper(SeuNome)) or (Upper(OMsgTo) = Upper(SeuHandle)) then
       OMsgTo := 'mim';
    if (Upper(OMsgFrom) = Upper(RMsgTo)) then
       OMsgFrom := 'vocˆ'; }
    
        {Cria‡„o do HEADER conforme arquivo indicado no EOEC.CFG}
    
    assign(head,SeuHeader);
    reset(head);
    
    { Buffer := ''; }
    
        {lˆ cada linha do arquivo de header e aplica macros correspondentes}
    
    while not Eof(head) do
    begin
         readln(head,Buffer);
         WriteMacroLine(rep,1,Buffer);
    end;
    
        {mais uma linha depois do header}
    
    writeln(rep);

end; {DoHeader}

(* ---------------------------------------------------------------------- *)
procedure ShareDelay(Tempo: Byte);
    (* D  um delay de "tempo" segundos, com mensagem de pausa *)

begin

    CursorOff;
    while Tempo > 0 do
    begin
         write('Pausa por ',Tempo,' segundos...   ',Chr(13));
         delay(1000);
         dec(Tempo);
    end;
    writeln('Ok. Pausa encerrada.                          ');
    CursorOn;

end; {ShareDelay}

(* ---------------------------------------------------------------------- *)
procedure DoBottom;
    (* Coloca assinatura e tagline *)

Var Taglines : Word;  {quantidade de taglines no arquivo de tags}

begin

    assign(F,SeuLogo);
    reset(F);

    append(rep);

    while not Eof(F) do
    begin
         Readln(F, Buffer);
         WriteMacroLine(rep,2,Buffer);
    end;

    close(F);

    writeln(rep);

    Taglines := 0;

    assign(F,SeuTaglines);
    reset(F);

    while not Eof(F) do
    begin
         Readln(F);
         Inc(Taglines);
    end;

    randomize;
    append(rep);
    WriteMacroLine(rep,2,'... '+GetLine(F,Random(Taglines)+1));
    if reg = true then writeln(rep,'~~~ EOEC/OLX v1.2á [REG]');
    if reg = false then writeln(rep,'~~~ EOEC/OLX v1.2á [NR] - God save the OLX!');

    close(rep);

end;



(* ====================================================================== *)
begin {Main Program}

    Logo;                     {Logotipo inicial do programa}
    Verify_Param;             {Verifica a entrada de um parƒmetro (REPLY)}
    CreateVars;               {Cria vari veis work, reply, original e header}
    CfgRead;                  {Lˆ configura‡„o do arquivo EOEC.CFG}
    
    assign(rep,reply);        {Arquivo REPLY = rep}
    assign(hdr,header);       {Arquivo HEADER.DAT = hdr}
    assign(ori,original);     {Arquivo ORIGINAL = ori}
    
    if FileExists(reply) then   {Verifica se a mensagem ‚ reedi‡„o de mensagem}
        Reeditflag := True      {pr¢pria ou n„o      1a edi‡„o    Reedi‡„o}
    else                                   {           Ori Rep     Ori Rep}
        if not FileExists(original) then   {  New       n   n       n   s }
            Newflag := True;               {  Reply     s   n       s   s }
                                           {  Mensagem minha        s   s }

    DoVars;

    if (not Reeditflag) and (not Newflag) then
    begin
         DoHeader;
         Append(rep);
         Reset(ori);
         for C := 1 to 7 do readln(ori);
         while not Eof(ori) do
         begin
               readln(ori,Buffer);
               writeln(rep,LimpaLinha(Buffer));
         end;
         Close(rep);
         Close(ori);
    end;


    { debug procedures
    writeln('EOEC est  para entrar no editor, chamando:');
    writeln(SeuEditor,' '+SeuEditorParam+' '+reply);
    readkey;
     end debug }

    SwapVectors;
    Exec(SeuEditor,' '+SeuEditorParam+' '+reply);
    SwapVectors;

    if DosError <> 0 then
    begin
         clrscr;
         TextColor(LightRed);
         writeln('Erro de execu‡„o no EOEC:');
         TextColor(LightGray);
         writeln('Contate Ernesto Baschny, informando erro #001-',DosError);
         CursorOff;
         readkey;
         CursorOn;
         halt(2);
    end;

    if not FileExists(reply) then
    begin
         clrscr;
         TextColor(LightRed);
         writeln('ERRO: N„o foi criado um arquivo de resposta: ',reply);
         TextColor(LightGray);
         writeln;
         writeln('Pressione alguma tecla para retornar');
         CursorOff;
         readkey;
         CursorOn;
         halt(2);
    end;

    if not Reeditflag then DoBottom;

    clrscr;
    writeln('Obrigado por usar o EOEC v1.2á.');
    CheckBreak := False;

    if reg = false then
    begin
        writeln;
        writeln('Contate ERNESTO BASCHNY para retirar essa mensagem. N„o ‚ necess rio nenhum');
        write('pagamento. ');
        TextColor(White);
        writeln('Este programa ‚ Freeware.');
        TextColor(LightGray);
        writeln;
        writeln('O contato s¢ precisa ser feito para que eu possa manter o controle de quem');
        writeln('o usa.');
        writeln;
        writeln('Obrigado pela compreens„o,');
        writeln('       Ernesto Baschny');
        writeln;
        writeln('  E VIVA O OLX!');
        writeln;
        ShareDelay(5);
    end;

end. {Main Program}