unit uoddfaceconfig;

{$mode delphi}

interface

uses
  Classes, SysUtils, urosx, uConstantesSimSEE;

const
  VERSION_ODDFACE_CONFIG = 3;

type

 { TOddFaceConfigPerfil }

 TOddFaceConfigPerfil = class
   nombrePerfil: string;
   UsuarioSimSEE: string;
   ClaveSimSEE: string;
   ros_ip: string;
   ros_host: string;
   ros_port: string;
   ros_uri: string; // uri a la rosx
   proxy_host: string;
   proxy_port: string;
   proxy_user: string;
   proxy_pass: string;
   flg_recordar_clave_proxy: boolean;
   flg_recordar_clave_simsee: boolean;

   constructor CreateDefault;
   constructor CreateReadFromText( var fconfig: textfile; version: integer );
   procedure WriteToText( var fconfig: textfile);
   function CreateClone: TOddFaceConfigPerfil;
 end;

  { TOddFaceConfigRec }
 TOddFaceConfigRec = class
   Version: integer;
   perfiles: TList;
   kPerfilActivo: integer;

   // Guarda la configuración
   procedure Save;

   // no use estas funciones, en lugar de ello use get_oddface_cfg
   constructor CreateLoad;
   constructor CreateEmpty;

   function NombresPerfiles: TStringList;
   function PerfilActivo: TOddFaceConfigPerfil;
   function GetPerfil( nombre: string ): TOddFaceConfigPerfil;
 end;



 // Si aún no fue leida/creada la lee o la crea y retorna puntero.
function get_OddFace_cfg: TOddFaceConfigRec;


implementation

var
  oddface_cfg: TOddFaceConfigRec;



  // Si aún no fue leida/creada la lee o la crea y retorna puntero.
function get_OddFace_cfg: TOddFaceConfigRec;
begin
  if oddface_cfg = nil then
    oddface_cfg:= TOddFaceConfigRec.CreateLoad;
  result:= oddface_cfg;
end;

function archi_oddface_cfg: string;
begin
  result:= getDir_Bin+'oddface.cfg';
end;

function getpal( var fconfig: textfile ): string;
var
  pal: string;
begin
  if not eof( fconfig ) then
  begin
    readln( fconfig, pal );
    result:= desbarullar( pal )
  end
  else
    result:= '';
end;


{ TOddFaceConfigPerfil }

constructor TOddFaceConfigPerfil.CreateDefault;
begin
  NombrePerfil:= 'Por defecto';
  UsuarioSimSEE:= '???';
  ClaveSimSEE:= '???';
  ros_ip:= '';
  ros_host:= '';
  ros_port:= '';
  ros_uri:= '';
  proxy_host:= '';
  proxy_port:= '';
  proxy_user:= '';
  proxy_pass:= '';
  flg_recordar_clave_proxy:= false;
  flg_recordar_clave_simsee:= false;
end;

constructor TOddFaceConfigPerfil.CreateReadFromText( var fconfig: textfile;
  version: integer);
begin
  if version >= 3 then
    NombrePerfil := getpal( fconfig )
  else
    NombrePerfil := 'Por defecto';

  UsuarioSimSEE:= getpal( fconfig );
  ClaveSimSEE:= getpal( fconfig );
  if version >= 2 then
  begin
    ros_ip:= getpal( fconfig );
    ros_host:= getpal( fconfig );
    ros_port:= getpal( fconfig );
    ros_uri:= getpal( fconfig );
  end;
  proxy_host:= getpal( fconfig );
  proxy_port:= getpal( fconfig );
  proxy_user:= getpal( fconfig );
  proxy_pass:= getpal( fconfig );
  flg_recordar_clave_proxy:= getpal( fconfig ) = '1';
  flg_recordar_clave_simsee:= getpal( fconfig ) = '1';
end;

procedure TOddFaceConfigPerfil.WriteToText( var fconfig: textfile );
begin
  writeln( fconfig, barullar( NombrePerfil ));
  writeln( fconfig, barullar( UsuarioSimSEE ));
  if flg_recordar_clave_simsee then
   writeln( fconfig, barullar( ClaveSimSEE ))
  else
   writeln( fconfig, '' );

  writeln( fconfig, barullar( ros_ip ));
  writeln( fconfig, barullar( ros_host ));
  writeln( fconfig, barullar( ros_port ));
  writeln( fconfig, barullar( ros_uri ));

  writeln( fconfig, barullar( proxy_host ));
  writeln( fconfig, barullar( proxy_port ));
  writeln( fconfig, barullar( proxy_user ));
  if flg_recordar_clave_proxy then
   writeln( fconfig, barullar( proxy_pass ))
  else
   writeln( fconfig, '');

  if flg_recordar_clave_proxy then
    writeln( fconfig, barullar( '1' ) )
  else
   writeln( fconfig, barullar( '0' ) );

  if flg_recordar_clave_simsee then
    writeln( fconfig, barullar( '1' ) )
  else
    writeln( fconfig, barullar( '0' ) );

end;

function TOddFaceConfigPerfil.CreateClone: TOddFaceConfigPerfil;
var
  aPerfil: TOddFaceConfigPerfil;
begin
  aPerfil:= TOddFaceConfigPerfil.CreateDefault;
  aPerfil.nombrePerfil:= '_clon_';
  aPerfil.UsuarioSimSEE:= UsuarioSimSEE;
  aPerfil.ClaveSimSEE:= ClaveSimSEE;
  aPerfil.ros_ip:= ros_ip;
  aPerfil.ros_host:= ros_host;
  aPerfil.ros_port:= ros_port;
  aPerfil.ros_uri:= ros_uri; // uri a la rosx
  aPerfil.proxy_host:= proxy_host;
  aPerfil.proxy_port:= proxy_port;
  aPerfil.proxy_user:= proxy_user;
  aPerfil.proxy_pass:= proxy_pass;
  aPerfil.flg_recordar_clave_proxy:= flg_recordar_clave_proxy;
  aPerfil.flg_recordar_clave_simsee:= flg_recordar_clave_simsee;
  result:= aPerfil;
end;

{ TOddFaceConfigRec }

constructor TOddFaceConfigRec.CreateLoad;
var
  fconfig: textfile;
  archi: string;
  OldFileMode: integer;
  NPerfiles: integer;
  kPerfil: integer;
  aPerfil: TOddFaceConfigPerfil;

begin
  CreateEmpty;
  archi := archi_oddface_cfg;
  if fileexists( archi ) then
  try
    OldFileMode:= filemode;
    filemode:= 0;
    assignfile( fconfig, archi );
    reset( fconfig );
    readln( fconfig, version ); // versión del archivo

    for kPerfil:= 0 to Perfiles.Count -1 do
    begin
      aPerfil:= Perfiles[kPerfil];
      aPerfil.Free;
    end;
    Perfiles.Clear;

    if version <= 2 then
    begin
      kPerfilActivo:= 0;
      NPerfiles:= 1;
    end
    else
    begin
      readln( fconfig, kPerfilActivo );
      readln( fconfig, NPerfiles );
    end;

    for kPerfil:= 1 to NPerfiles do
    begin
      aPerfil:= TOddFaceConfigPerfil.CreateReadFromText( fconfig, version );
      Perfiles.Add( aPerfil );
    end;
    closefile( fconfig );
  except
    // nada
  end;
  fileMode:= OldFileMode;
end;


constructor TOddFaceConfigRec.CreateEmpty;
begin
  inherited Create;
  Perfiles:= Tlist.Create;
  Perfiles.add( TOddFaceConfigPerfil.CreateDefault );
  kPerfilActivo:= 0;
end;

function TOddFaceConfigRec.NombresPerfiles: TStringList;
var
  res: TStringList;
  kPerfil: integer;
  aPerfil: TOddFaceConfigPerfil;
begin
  res:= TStringList.Create;
  for kPerfil:= 0 to Perfiles.count - 1 do
  begin
    aPerfil:= Perfiles[kPerfil];
    res.add( aPerfil.nombrePerfil );
  end;
  result:= res;
end;

function TOddFaceConfigRec.PerfilActivo: TOddFaceConfigPerfil;
begin
  result:= Perfiles[kPerfilActivo];
end;

function TOddFaceConfigRec.GetPerfil(nombre: string): TOddFaceConfigPerfil;
var
  aPerfil: TOddFaceConfigPerfil;
  k: integer;
  buscando: boolean;
begin
  k:= 0;
  buscando:= true;
  while buscando and ( k < perfiles.Count ) do
  begin
    aPerfil:= perfiles[k];
    if aPerfil.nombrePerfil = nombre then
      buscando:= false
    else
      inc( k );
  end;

  if buscando then
    result:= nil
  else
    result:= aPerfil;

end;

procedure TOddFaceConfigRec.Save;
var
  OldFileMode: integer;
  fconfig: textfile;
  kPerfil: integer;
  aPerfil: TOddFaceConfigPerfil;
begin
  OldFileMode:= fileMode;
  filemode:= 1;
  try
  assignfile( fconfig, archi_oddface_cfg );
  rewrite( fconfig );
  writeln( fconfig, VERSION_ODDFACE_CONFIG); // versión del archivo
  writeln( fconfig, kPerfilActivo );
  writeln( fconfig, Perfiles.Count );
  for kPerfil:= 0 to Perfiles.Count-1 do
  begin
    aPerfil:= perfiles[kPerfil];
    aPerfil.WriteToText( fconfig );
  end;
  closefile( fconfig );

  finally
    filemode:= OldFileMode;
  end;
end;

initialization
  oddface_cfg:= nil;

finalization
  if oddface_cfg <> nil then
  begin
   oddface_cfg.Free;
   oddface_cfg:= nil;
  end;
end.

