﻿unit uPesadoConfig;

{ Configuración persistente de la báscula, reglas de control de peso y conexión a BD.
  Se almacena íntegramente cifrada en ControlPesado.cfg junto al ejecutable. }

interface

uses
  System.SysUtils, System.Classes, System.IniFiles;

const
  CONFIG_PASSWORD = 'admin';

type
  TUnidadPeso = (upKg = 0, upGramos = 1);

  TPesadoConfig = record
    // --- Conexión a Base de Datos (MariaDB / MySQL) ---
    DBServer: string;
    DBPort: Integer;
    DBDatabase: string;
    DBUser: string;
    DBPassword: string;

    // --- Comunicación serie ---
    Puerto: string;             // COM1, COM2...
    BaudRate: Integer;
    DataBits: Integer;          // 7 / 8
    Paridad: Integer;           // 0 None, 1 Odd, 2 Even
    StopBits: Integer;          // 0 = 1 bit, 1 = 1.5 bits, 2 = 2 bits
    ComandoPeticionHex: string; // Comando en cada sondeo (hex, ej. "05" = ENQ). Vacío = continuo
    IntervaloMs: Integer;       // Intervalo de sondeo / lectura
    UnidadTrama: TUnidadPeso;   // Unidad por defecto si la trama no indica "kg"/"g"
    Simulado: Boolean;          // Simulador sin báscula física

    // --- Reglas de control ---
    UnidadArticulo: TUnidadPeso; // Unidad en la que está ge_articulos.peso
    ToleranciaPorc: Double;     // Déficit máximo admitido (2 %)
    TaraEnvaseGr: Double;       // Gramos a descontar del bruto (envase)
    PesoMinimoGr: Double;       // Peso a partir del cual se considera que hay artículo en el plato
    UmbralCeroGr: Double;       // Por debajo de este peso el plato se considera vacío (rearme)
    MuestrasEstables: Integer;
    ToleranciaEstableGr: Double;
    SonidoActivo: Boolean;

    class function Defecto: TPesadoConfig; static;
    class function Cargar: TPesadoConfig; static;
    procedure Guardar;
  end;

function RutaCfgPesado: string;
function EncryptConfigText(const APlainText: string): string;
function DecryptConfigText(const ACipherText: string): string;

implementation

const
  CFG_HEADER = 'PESADOCFG1:';
  CFG_KEY_BASE: Word = $C79A;
  GESTION_ENC_KEY: Word = $A5C3;

function RutaCfgPesado: string;
begin
  Result := IncludeTrailingPathDelimiter(ExtractFilePath(ParamStr(0))) + 'ControlPesado.cfg';
end;

function RutaIniLegacy: string;
begin
  Result := IncludeTrailingPathDelimiter(ExtractFilePath(ParamStr(0))) + 'ControlPesado.ini';
end;

function DecryptGestionStr(const AText: string): string;
var
  I, LVal: Integer;
  LCipher: string;
begin
  if not SameText(Copy(AText, 1, 4), 'ENC:') then
    Exit(AText);
  LCipher := Copy(AText, 5, MaxInt);
  Result := '';
  I := 1;
  while I < Length(LCipher) do
  begin
    if TryStrToInt('$' + Copy(LCipher, I, 4), LVal) then
      Result := Result + Char(Word(LVal) xor GESTION_ENC_KEY);
    Inc(I, 4);
  end;
end;

function EncryptConfigText(const APlainText: string): string;
var
  LBytes: TBytes;
  I: Integer;
  LKey, LByteCipher: Word;
  LSB: TStringBuilder;
begin
  LBytes := TEncoding.UTF8.GetBytes(APlainText);
  LKey := CFG_KEY_BASE;
  LSB := TStringBuilder.Create(Length(CFG_HEADER) + Length(LBytes) * 4);
  try
    LSB.Append(CFG_HEADER);
    for I := 0 to High(LBytes) do
    begin
      LByteCipher := (Word(LBytes[I]) xor LKey) and $FFFF;
      LSB.Append(IntToHex(LByteCipher, 4));
      LKey := Word(((LKey * 31) + LByteCipher + Word(I)) and $FFFF);
    end;
    Result := LSB.ToString;
  finally
    LSB.Free;
  end;
end;

function DecryptConfigText(const ACipherText: string): string;
var
  LHex: string;
  LBytes: TBytes;
  I, LCount, LVal: Integer;
  LKey: Word;
begin
  LHex := Trim(ACipherText);
  if not SameText(Copy(LHex, 1, Length(CFG_HEADER)), CFG_HEADER) then
    Exit(ACipherText);

  Delete(LHex, 1, Length(CFG_HEADER));
  LCount := Length(LHex) div 4;
  SetLength(LBytes, LCount);
  LKey := CFG_KEY_BASE;
  for I := 0 to LCount - 1 do
  begin
    if not TryStrToInt('$' + Copy(LHex, I * 4 + 1, 4), LVal) then
      Exit('');
    LBytes[I] := Byte((Word(LVal) xor LKey) and $FF);
    LKey := Word(((LKey * 31) + Word(LVal) + Word(I)) and $FFFF);
  end;
  Result := TEncoding.UTF8.GetString(LBytes);
end;

procedure CargarDBDesdeGestionIni(var AConfig: TPesadoConfig);
var
  LPath: string;
  LIni: TIniFile;
begin
  LPath := IncludeTrailingPathDelimiter(ExtractFilePath(ParamStr(0))) + 'db_config.ini';
  if not FileExists(LPath) and FileExists('C:\GESTIGEST\db_config.ini') then
    LPath := 'C:\GESTIGEST\db_config.ini';
  if not FileExists(LPath) then
    Exit;

  LIni := TIniFile.Create(LPath);
  try
    AConfig.DBServer := DecryptGestionStr(LIni.ReadString('Database', 'Server', AConfig.DBServer));
    AConfig.DBPort := StrToIntDef(DecryptGestionStr(LIni.ReadString('Database', 'Port', IntToStr(AConfig.DBPort))), AConfig.DBPort);
    AConfig.DBDatabase := DecryptGestionStr(LIni.ReadString('Database', 'Database', AConfig.DBDatabase));
    AConfig.DBUser := DecryptGestionStr(LIni.ReadString('Database', 'User_Name', AConfig.DBUser));
    AConfig.DBPassword := DecryptGestionStr(LIni.ReadString('Database', 'Password', AConfig.DBPassword));
  finally
    LIni.Free;
  end;
end;

{ TPesadoConfig }

class function TPesadoConfig.Defecto: TPesadoConfig;
begin
  Result.DBServer := '85.215.144.168';
  Result.DBPort := 3306;
  Result.DBDatabase := 'pastelerias';
  Result.DBUser := 'asesoft';
  Result.DBPassword := 'Pantera1';

  Result.Puerto := 'COM1';
  Result.BaudRate := 9600;
  Result.DataBits := 8;
  Result.Paridad := 0;
  Result.StopBits := 0;
  Result.ComandoPeticionHex := '';
  Result.IntervaloMs := 150;
  Result.UnidadTrama := upKg;
  Result.Simulado := False;

  Result.UnidadArticulo := upKg;
  Result.ToleranciaPorc := 2.0;
  Result.TaraEnvaseGr := 0;
  Result.PesoMinimoGr := 20;
  Result.UmbralCeroGr := 10;
  Result.MuestrasEstables := 4;
  Result.ToleranciaEstableGr := 2;
  Result.SonidoActivo := True;
end;

class function TPesadoConfig.Cargar: TPesadoConfig;
var
  LMemIni: TMemIniFile;
  LStrings: TStringList;
  LRaw, LDecoded: string;
begin
  Result := Defecto;
  CargarDBDesdeGestionIni(Result);

  if not FileExists(RutaCfgPesado) and not FileExists(RutaIniLegacy) then
  begin
    Result.Guardar;
    Exit;
  end;

  LStrings := TStringList.Create;
  LMemIni := TMemIniFile.Create('');
  try
    if FileExists(RutaCfgPesado) then
    begin
      LStrings.LoadFromFile(RutaCfgPesado, TEncoding.UTF8);
      LRaw := Trim(LStrings.Text);
      LDecoded := DecryptConfigText(LRaw);
      LStrings.Text := LDecoded;
    end
    else if FileExists(RutaIniLegacy) then
      LStrings.LoadFromFile(RutaIniLegacy, TEncoding.UTF8);

    LMemIni.SetStrings(LStrings);

    Result.DBServer := LMemIni.ReadString('DATABASE', 'Server', Result.DBServer);
    Result.DBPort := LMemIni.ReadInteger('DATABASE', 'Port', Result.DBPort);
    Result.DBDatabase := LMemIni.ReadString('DATABASE', 'Database', Result.DBDatabase);
    Result.DBUser := LMemIni.ReadString('DATABASE', 'User', Result.DBUser);
    Result.DBPassword := LMemIni.ReadString('DATABASE', 'Password', Result.DBPassword);

    Result.Puerto := LMemIni.ReadString('BASCULA', 'Puerto', Result.Puerto);
    Result.BaudRate := LMemIni.ReadInteger('BASCULA', 'BaudRate', Result.BaudRate);
    Result.DataBits := LMemIni.ReadInteger('BASCULA', 'DataBits', Result.DataBits);
    Result.Paridad := LMemIni.ReadInteger('BASCULA', 'Paridad', Result.Paridad);
    Result.StopBits := LMemIni.ReadInteger('BASCULA', 'StopBits', Result.StopBits);
    Result.ComandoPeticionHex := LMemIni.ReadString('BASCULA', 'ComandoPeticionHex', Result.ComandoPeticionHex);
    Result.IntervaloMs := LMemIni.ReadInteger('BASCULA', 'IntervaloMs', Result.IntervaloMs);
    Result.UnidadTrama := TUnidadPeso(LMemIni.ReadInteger('BASCULA', 'UnidadTrama', Ord(Result.UnidadTrama)) mod 2);
    Result.Simulado := LMemIni.ReadBool('BASCULA', 'Simulado', Result.Simulado);

    Result.UnidadArticulo := TUnidadPeso(LMemIni.ReadInteger('CONTROL', 'UnidadArticulo', Ord(Result.UnidadArticulo)) mod 2);
    Result.ToleranciaPorc := LMemIni.ReadFloat('CONTROL', 'ToleranciaPorc', Result.ToleranciaPorc);
    Result.TaraEnvaseGr := LMemIni.ReadFloat('CONTROL', 'TaraEnvaseGr', Result.TaraEnvaseGr);
    Result.PesoMinimoGr := LMemIni.ReadFloat('CONTROL', 'PesoMinimoGr', Result.PesoMinimoGr);
    Result.UmbralCeroGr := LMemIni.ReadFloat('CONTROL', 'UmbralCeroGr', Result.UmbralCeroGr);
    Result.MuestrasEstables := LMemIni.ReadInteger('CONTROL', 'MuestrasEstables', Result.MuestrasEstables);
    Result.ToleranciaEstableGr := LMemIni.ReadFloat('CONTROL', 'ToleranciaEstableGr', Result.ToleranciaEstableGr);
    Result.SonidoActivo := LMemIni.ReadBool('CONTROL', 'SonidoActivo', Result.SonidoActivo);
  finally
    LMemIni.Free;
    LStrings.Free;
  end;

  if Result.MuestrasEstables < 2 then
    Result.MuestrasEstables := 2;
  if Result.IntervaloMs < 20 then
    Result.IntervaloMs := 20;
  if Result.DBPort <= 0 then
    Result.DBPort := 3306;

  // Si provenía del archivo en texto plano antiguo, guardarlo cifrado y borrar el antiguo
  if FileExists(RutaIniLegacy) then
  begin
    Result.Guardar;
    DeleteFile(RutaIniLegacy);
  end;
end;

procedure TPesadoConfig.Guardar;
var
  LMemIni: TMemIniFile;
  LStrings, LOut: TStringList;
begin
  LMemIni := TMemIniFile.Create('');
  LStrings := TStringList.Create;
  LOut := TStringList.Create;
  try
    LMemIni.WriteString('DATABASE', 'Server', DBServer);
    LMemIni.WriteInteger('DATABASE', 'Port', DBPort);
    LMemIni.WriteString('DATABASE', 'Database', DBDatabase);
    LMemIni.WriteString('DATABASE', 'User', DBUser);
    LMemIni.WriteString('DATABASE', 'Password', DBPassword);

    LMemIni.WriteString('BASCULA', 'Puerto', Puerto);
    LMemIni.WriteInteger('BASCULA', 'BaudRate', BaudRate);
    LMemIni.WriteInteger('BASCULA', 'DataBits', DataBits);
    LMemIni.WriteInteger('BASCULA', 'Paridad', Paridad);
    LMemIni.WriteInteger('BASCULA', 'StopBits', StopBits);
    LMemIni.WriteString('BASCULA', 'ComandoPeticionHex', ComandoPeticionHex);
    LMemIni.WriteInteger('BASCULA', 'IntervaloMs', IntervaloMs);
    LMemIni.WriteInteger('BASCULA', 'UnidadTrama', Ord(UnidadTrama));
    LMemIni.WriteBool('BASCULA', 'Simulado', Simulado);

    LMemIni.WriteInteger('CONTROL', 'UnidadArticulo', Ord(UnidadArticulo));
    LMemIni.WriteFloat('CONTROL', 'ToleranciaPorc', ToleranciaPorc);
    LMemIni.WriteFloat('CONTROL', 'TaraEnvaseGr', TaraEnvaseGr);
    LMemIni.WriteFloat('CONTROL', 'PesoMinimoGr', PesoMinimoGr);
    LMemIni.WriteFloat('CONTROL', 'UmbralCeroGr', UmbralCeroGr);
    LMemIni.WriteInteger('CONTROL', 'MuestrasEstables', MuestrasEstables);
    LMemIni.WriteFloat('CONTROL', 'ToleranciaEstableGr', ToleranciaEstableGr);
    LMemIni.WriteBool('CONTROL', 'SonidoActivo', SonidoActivo);

    LMemIni.GetStrings(LStrings);
    LOut.Text := EncryptConfigText(LStrings.Text);
    LOut.SaveToFile(RutaCfgPesado, TEncoding.UTF8);
  finally
    LOut.Free;
    LStrings.Free;
    LMemIni.Free;
  end;
end;

end.
