unit uRegularizarLotesFabricacionLogic;

interface

uses
  System.SysUtils, System.Classes, System.Generics.Collections, System.Math,
  Data.DB, FireDAC.Comp.Client, FireDAC.Stan.Param;

type
  TInventarioMPItem = record
    Id: Integer;
    Fecha: TDateTime;
    IdEmpresa: Integer;
    IdAlmacen: Integer;
    AlmacenNombre: string;
    Descripcion: string;
    Regularizado: Boolean;
  end;

  TMateriaPrimaSinProveedor = record
    IdMateriaPrima: Integer;
    Descripcion: string;
    Origen: string;
  end;

  TResultadoOrden = record
    ElaboracionId: Integer;
    Fecha: TDateTime;
    LoteId: Integer;
    LoteCodigo: string;
    RecetaId: Integer;
    RecetaDesc: string;
    Multiplicador: Double;
    IngredientesInsertados: Integer;
    IngredientesActualizados: Integer;
    EnvasesInsertados: Integer;
    EnvasesActualizados: Integer;
    LotesAsignados: Integer;
    LotesDivididos: Integer;
    TuvoStockNegativo: Boolean;
    SinStockPositivo: Boolean;
    Estado: string;
    Detalle: string;
  end;

  TResultadoRegularizacion = class
  public
    Exito: Boolean;
    ParalizadoPorProveedores: Boolean;
    Simulacion: Boolean;
    FechaInicio: TDateTime;
    TotalOrdenes: Integer;
    TotalIngInsertados: Integer;
    TotalIngActualizados: Integer;
    TotalEnvInsertados: Integer;
    TotalEnvActualizados: Integer;
    TotalLotesAsignados: Integer;
    TotalOrdenesConNegativo: Integer;
    TotalOrdenesSinStockPositivo: Integer;
    MensajeResumen: string;
    SinProveedor: TList<TMateriaPrimaSinProveedor>;
    Ordenes: TList<TResultadoOrden>;
    constructor Create;
    destructor Destroy; override;
  end;

  TRegularizarLotesFabricacionLogic = class
  private
    class function ConvertirAUnidadBase(ACantidad: Double; const AUnidad: string; out AUnidadBase: string): Double;
    class function ConvertirDesdeUnidadBase(ACantidadBase: Double; const AUnidadDestino: string): Double;
    class function UnidadesCompatibles(const AUnidadA, AUnidadB: string): Boolean;
  public
    class function ListarInventariosMP(AEmpresaId: Integer): TList<TInventarioMPItem>;
    class function EjecutarProceso(AInventarioId, AEmpresaId, AUsuarioId: Integer;
      ASimular: Boolean): TResultadoRegularizacion;
  end;

implementation

uses
  dmg_Main, uDbErrorHandler;

type
  TExpectedMP = class
  public
    IdMateriaPrima: Integer;
    CantidadBase: Double;
    UnidadBase: string;
    EsEnvase: Boolean;
    EsReceta: Boolean;
  end;

  TEntradaPoolItem = class
  public
    Id: Integer;
    IdMateriaPrima: Integer;
    IdAlmacen: Integer;
    FechaEntrada: TDateTime;
    Lote: string;
    CantidadCompra: Double;
    StockActual: Double;
    Modificada: Boolean;
  end;

  TConsumoRow = record
    Id: Integer;
    IdMateriaPrima: Integer;
    Cantidad: Double;
    CantidadTeorica: Double;
    CantidadReal: Double;
    Unidad: string;
  end;

{ TResultadoRegularizacion }

constructor TResultadoRegularizacion.Create;
begin
  inherited Create;
  SinProveedor := TList<TMateriaPrimaSinProveedor>.Create;
  Ordenes := TList<TResultadoOrden>.Create;
end;

destructor TResultadoRegularizacion.Destroy;
begin
  SinProveedor.Free;
  Ordenes.Free;
  inherited Destroy;
end;

{ TRegularizarLotesFabricacionLogic }

class function TRegularizarLotesFabricacionLogic.ConvertirAUnidadBase(ACantidad: Double;
  const AUnidad: string; out AUnidadBase: string): Double;
var
  LU: string;
begin
  LU := LowerCase(Trim(AUnidad));
  if (LU = 'g') or (LU = 'gr') or (LU = 'gramo') or (LU = 'gramos') then
  begin
    AUnidadBase := 'kg';
    Result := ACantidad / 1000.0;
  end
  else if (LU = 'kg') or (LU = 'kgs') or (LU = 'kilo') or (LU = 'kilos') then
  begin
    AUnidadBase := 'kg';
    Result := ACantidad;
  end
  else if (LU = 'ml') or (LU = 'cc') then
  begin
    AUnidadBase := 'l';
    Result := ACantidad / 1000.0;
  end
  else if LU = 'cl' then
  begin
    AUnidadBase := 'l';
    Result := ACantidad / 100.0;
  end
  else if (LU = 'l') or (LU = 'litro') or (LU = 'litros') then
  begin
    AUnidadBase := 'l';
    Result := ACantidad;
  end
  else if (LU = '') or (LU = 'ud') or (LU = 'uds') or (LU = 'u') or (LU = 'unidad') or (LU = 'unidades') then
  begin
    AUnidadBase := 'ud';
    Result := ACantidad;
  end
  else
  begin
    AUnidadBase := LU;
    Result := ACantidad;
  end;
end;

class function TRegularizarLotesFabricacionLogic.ConvertirDesdeUnidadBase(ACantidadBase: Double;
  const AUnidadDestino: string): Double;
var
  LU: string;
begin
  LU := LowerCase(Trim(AUnidadDestino));
  if (LU = 'g') or (LU = 'gr') or (LU = 'gramo') or (LU = 'gramos') or
     (LU = 'ml') or (LU = 'cc') then
    Result := ACantidadBase * 1000.0
  else if LU = 'cl' then
    Result := ACantidadBase * 100.0
  else
    Result := ACantidadBase;
end;

class function TRegularizarLotesFabricacionLogic.UnidadesCompatibles(const AUnidadA,
  AUnidadB: string): Boolean;
var
  LA, LB, LBaseA, LBaseB: string;
begin
  ConvertirAUnidadBase(1.0, AUnidadA, LBaseA);
  ConvertirAUnidadBase(1.0, AUnidadB, LBaseB);
  LA := LBaseA;
  LB := LBaseB;
  Result := LA = LB;
end;

class function TRegularizarLotesFabricacionLogic.ListarInventariosMP(
  AEmpresaId: Integer): TList<TInventarioMPItem>;
var
  LQry: TFDQuery;
  LItem: TInventarioMPItem;
begin
  Result := TList<TInventarioMPItem>.Create;
  LQry := TFDQuery.Create(nil);
  try
    LQry.Connection := dmgMain.dbConn;
    LQry.SQL.Text :=
      'SELECT inv.id, inv.fecha, inv.id_empresa, inv.id_almacen, ' +
      '       COALESCE((SELECT o.nombre FROM ge_obradores o WHERE o.id_almacen = inv.id_almacen AND o.activo = 1 LIMIT 1), alm.descripcion, ''Obrador'') AS almacen_nombre, ' +
      '       COALESCE(inv.descripcion, '''') AS descripcion, inv.regularizado ' +
      'FROM ge_inventarios inv ' +
      'LEFT JOIN ge_almacenes alm ON inv.id_almacen = alm.id ' +
      'WHERE inv.id_empresa = :emp ' +
      '  AND (EXISTS (SELECT 1 FROM ge_inventarios_lineas il ' +
      '               WHERE il.id_inventario = inv.id AND il.id_materia_prima IS NOT NULL) ' +
      '       OR (NOT EXISTS (SELECT 1 FROM ge_inventarios_lineas il_any WHERE il_any.id_inventario = inv.id) ' +
      '           AND UPPER(COALESCE(inv.descripcion, '''')) NOT LIKE ''%ENVASADO%'' ' +
      '           AND UPPER(COALESCE(inv.descripcion, '''')) NOT LIKE ''%PRODUCTO%'')) ' +
      'ORDER BY inv.fecha DESC, inv.id DESC';
    LQry.ParamByName('emp').AsInteger := AEmpresaId;
    LQry.Open;

    while not LQry.Eof do
    begin
      LItem.Id := LQry.FieldByName('id').AsInteger;
      LItem.Fecha := LQry.FieldByName('fecha').AsDateTime;
      LItem.IdEmpresa := LQry.FieldByName('id_empresa').AsInteger;
      LItem.IdAlmacen := LQry.FieldByName('id_almacen').AsInteger;
      LItem.AlmacenNombre := LQry.FieldByName('almacen_nombre').AsString;
      LItem.Descripcion := LQry.FieldByName('descripcion').AsString;
      LItem.Regularizado := LQry.FieldByName('regularizado').AsInteger <> 0;
      Result.Add(LItem);
      LQry.Next;
    end;
  finally
    LQry.Free;
  end;
end;

class function TRegularizarLotesFabricacionLogic.EjecutarProceso(AInventarioId, AEmpresaId,
  AUsuarioId: Integer; ASimular: Boolean): TResultadoRegularizacion;
var
  LQryInv, LQryOrdenes, LQryRec, LQryEnv, LQryCons, LQryCheckProv, LQryPool, LQryExec: TFDQuery;
  LFechaInicio: TDateTime;
  LMpIdsGlobal: TDictionary<Integer, string>;
  LMpDescMap: TDictionary<Integer, string>;
  LExpectedMap: TObjectDictionary<Integer, TExpectedMP>;
  LEntradasPool: TObjectList<TEntradaPoolItem>;
  LEntradasPorMP: TDictionary<Integer, TList<TEntradaPoolItem>>;
  LInvStockByEntrada: TDictionary<Integer, Double>;
  LInvStockByMP: TDictionary<Integer, Double>;
  LEntryList: TList<TEntradaPoolItem>;
  LEntry, LBestEntry: TEntradaPoolItem;
  LConsList: TList<TConsumoRow>;
  LResOrden: TResultadoOrden;
  LMpSinProv: TMateriaPrimaSinProveedor;
  LRecetaId, LElabId, LLoteId: Integer;
  LMult, LCantBase, LCantEnv, LCantConsumir, LCantRestante, LUsedBase, LStockInv: Double;
  LUnidadBase, LUnidadDest, LDetalleOrden: string;
  LExpMP: TExpectedMP;
  LCons: TConsumoRow;
  I, J, K: Integer;
  LIdsComma: TStringBuilder;
  LFirstId: Boolean;
  LIdList: TList<Integer>;
  LTeoricaExistente: Double;
  LExistCount: Integer;
  LFirstConsId: Integer;
  LFirstConsUnidad: string;
  LEligibleList: TList<TEntradaPoolItem>;
  LHaveDateMatch: Boolean;
begin
  Result := TResultadoRegularizacion.Create;
  Result.Simulacion := ASimular;
  Result.Exito := False;
  Result.ParalizadoPorProveedores := False;

  LMpIdsGlobal := TDictionary<Integer, string>.Create;
  LMpDescMap := TDictionary<Integer, string>.Create;
  LExpectedMap := TObjectDictionary<Integer, TExpectedMP>.Create([doOwnsValues]);
  LEntradasPool := TObjectList<TEntradaPoolItem>.Create(True);
  LEntradasPorMP := TDictionary<Integer, TList<TEntradaPoolItem>>.Create;
  LInvStockByEntrada := TDictionary<Integer, Double>.Create;
  LInvStockByMP := TDictionary<Integer, Double>.Create;
  LConsList := TList<TConsumoRow>.Create;
  LEligibleList := TList<TEntradaPoolItem>.Create;

  LQryInv := TFDQuery.Create(nil);
  LQryOrdenes := TFDQuery.Create(nil);
  LQryRec := TFDQuery.Create(nil);
  LQryEnv := TFDQuery.Create(nil);
  LQryCons := TFDQuery.Create(nil);
  LQryCheckProv := TFDQuery.Create(nil);
  LQryPool := TFDQuery.Create(nil);
  LQryExec := TFDQuery.Create(nil);
  try
    LQryInv.Connection := dmgMain.dbConn;
    LQryOrdenes.Connection := dmgMain.dbConn;
    LQryRec.Connection := dmgMain.dbConn;
    LQryEnv.Connection := dmgMain.dbConn;
    LQryCons.Connection := dmgMain.dbConn;
    LQryCheckProv.Connection := dmgMain.dbConn;
    LQryPool.Connection := dmgMain.dbConn;
    LQryExec.Connection := dmgMain.dbConn;

    // 1. Obtener inventario seleccionado y su fecha
    LQryInv.SQL.Text :=
      'SELECT id, fecha, id_almacen, descripcion FROM ge_inventarios WHERE id = :id AND id_empresa = :emp';
    LQryInv.ParamByName('id').AsInteger := AInventarioId;
    LQryInv.ParamByName('emp').AsInteger := AEmpresaId;
    LQryInv.Open;
    if LQryInv.IsEmpty then
    begin
      Result.MensajeResumen := 'No se encontró el inventario de materias primas seleccionado.';
      Exit;
    end;
    LFechaInicio := LQryInv.FieldByName('fecha').AsDateTime;
    Result.FechaInicio := LFechaInicio;
    LQryInv.Close;

    // Cargar líneas del inventario para stock inicial por entrada o por materia prima
    LQryInv.SQL.Text :=
      'SELECT id_entrada_materia_prima, id_materia_prima, COALESCE(cantidad_real, stock_teorico, 0) AS qty_inv ' +
      'FROM ge_inventarios_lineas ' +
      'WHERE id_inventario = :id';
    LQryInv.ParamByName('id').AsInteger := AInventarioId;
    LQryInv.Open;
    while not LQryInv.Eof do
    begin
      if not LQryInv.FieldByName('id_entrada_materia_prima').IsNull then
        LInvStockByEntrada.AddOrSetValue(
          LQryInv.FieldByName('id_entrada_materia_prima').AsInteger,
          LQryInv.FieldByName('qty_inv').AsFloat)
      else if not LQryInv.FieldByName('id_materia_prima').IsNull then
        LInvStockByMP.AddOrSetValue(
          LQryInv.FieldByName('id_materia_prima').AsInteger,
          LQryInv.FieldByName('qty_inv').AsFloat);
      LQryInv.Next;
    end;
    LQryInv.Close;

    // 2. Cargar órdenes de fabricación desde la fecha del inventario (orden cronológico)
    LQryOrdenes.SQL.Text :=
      'SELECT e.id, e.fecha, e.id_receta, e.lote_id, e.multiplicador, ' +
      '       COALESCE(r.descripcion, ''Receta'') AS receta_desc, ' +
      '       COALESCE(l.codigo_antiguo, CAST(l.codigo AS CHAR), CAST(e.lote_id AS CHAR)) AS lote_codigo ' +
      'FROM ob_elaboraciones e ' +
      'LEFT JOIN ob_recetas r ON r.id = e.id_receta ' +
      'LEFT JOIN ge_lotes l ON l.id = e.lote_id ' +
      'WHERE e.fecha >= :fecha_inicio ' +
      'ORDER BY e.fecha ASC, e.id ASC';
    LQryOrdenes.ParamByName('fecha_inicio').AsDate := LFechaInicio;
    LQryOrdenes.Open;

    if LQryOrdenes.IsEmpty then
    begin
      Result.Exito := True;
      Result.MensajeResumen := Format('No se encontraron órdenes de fabricación desde el %s.',
        [FormatDateTime('dd/mm/yyyy', LFechaInicio)]);
      Exit;
    end;

    // 3. FASE PREVIA: Recolectar TODAS las materias primas implicadas (recetas, envases y consumos)
    //    y verificar que TODAS tengan al menos un artículo de proveedor activo asignado.
    LQryRec.SQL.Text :=
      'SELECT pi.id_materia_prima, COALESCE(NULLIF(mp.descripcion_trazabilidad, ''''), mp.descripcion) AS descripcion ' +
      'FROM ob_recetas_procesos rp ' +
      'JOIN ob_procesos_ingredientes pi ON pi.proceso_id = rp.id ' +
      'JOIN ge_materias_primas mp ON mp.id = pi.id_materia_prima ' +
      'WHERE rp.receta_id = :receta_id AND pi.tipo_origen = ''MP'' AND COALESCE(pi.en_trazabilidad, 1) = 1';

    LQryEnv.SQL.Text :=
      'SELECT fpm.id_materia_prima, COALESCE(NULLIF(mp.descripcion_trazabilidad, ''''), mp.descripcion) AS descripcion ' +
      'FROM ge_stock_envasado se ' +
      'JOIN ge_formatos_presentacion_materiales fpm ON fpm.id_formato_presentacion = se.id_formato_presentacion ' +
      'JOIN ge_materias_primas mp ON mp.id = fpm.id_materia_prima ' +
      'WHERE (se.id_lote = :lote_id ' +
      '       OR se.id_lote IN (SELECT rep.lote_inclusion_id FROM ob_elaboraciones_reparto rep ' +
      '                         WHERE rep.elaboracion_id = :elab_id AND rep.lote_inclusion_id IS NOT NULL)) ' +
      '  AND COALESCE(NULLIF(se.cantidad_producida, 0), se.cantidad_unidades, 0) > 0';

    LQryCons.SQL.Text :=
      'SELECT c.id_materia_prima, COALESCE(NULLIF(mp.descripcion_trazabilidad, ''''), mp.descripcion) AS descripcion ' +
      'FROM ob_lotes_consumidos c ' +
      'JOIN ge_materias_primas mp ON mp.id = c.id_materia_prima ' +
      'WHERE c.elaboracion_id = :elab_id AND c.id_materia_prima IS NOT NULL';

    LQryOrdenes.First;
    while not LQryOrdenes.Eof do
    begin
      LElabId := LQryOrdenes.FieldByName('id').AsInteger;
      LRecetaId := LQryOrdenes.FieldByName('id_receta').AsInteger;
      LLoteId := LQryOrdenes.FieldByName('lote_id').AsInteger;

      LQryRec.Close;
      LQryRec.ParamByName('receta_id').AsInteger := LRecetaId;
      LQryRec.Open;
      while not LQryRec.Eof do
      begin
        if not LMpIdsGlobal.ContainsKey(LQryRec.FieldByName('id_materia_prima').AsInteger) then
          LMpIdsGlobal.Add(LQryRec.FieldByName('id_materia_prima').AsInteger, 'Receta');
        LMpDescMap.AddOrSetValue(
          LQryRec.FieldByName('id_materia_prima').AsInteger,
          LQryRec.FieldByName('descripcion').AsString);
        LQryRec.Next;
      end;

      LQryEnv.Close;
      LQryEnv.ParamByName('lote_id').AsInteger := LLoteId;
      LQryEnv.ParamByName('elab_id').AsInteger := LElabId;
      LQryEnv.Open;
      while not LQryEnv.Eof do
      begin
        if not LMpIdsGlobal.ContainsKey(LQryEnv.FieldByName('id_materia_prima').AsInteger) then
          LMpIdsGlobal.Add(LQryEnv.FieldByName('id_materia_prima').AsInteger, 'Envase');
        LMpDescMap.AddOrSetValue(
          LQryEnv.FieldByName('id_materia_prima').AsInteger,
          LQryEnv.FieldByName('descripcion').AsString);
        LQryEnv.Next;
      end;

      LQryCons.Close;
      LQryCons.ParamByName('elab_id').AsInteger := LElabId;
      LQryCons.Open;
      while not LQryCons.Eof do
      begin
        if not LMpIdsGlobal.ContainsKey(LQryCons.FieldByName('id_materia_prima').AsInteger) then
          LMpIdsGlobal.Add(LQryCons.FieldByName('id_materia_prima').AsInteger, 'Consumo');
        LMpDescMap.AddOrSetValue(
          LQryCons.FieldByName('id_materia_prima').AsInteger,
          LQryCons.FieldByName('descripcion').AsString);
        LQryCons.Next;
      end;

      LQryOrdenes.Next;
    end;

    if LMpIdsGlobal.Count > 0 then
    begin
      LIdsComma := TStringBuilder.Create;
      try
        LFirstId := True;
        for I in LMpIdsGlobal.Keys do
        begin
          if not LFirstId then LIdsComma.Append(',');
          LFirstId := False;
          LIdsComma.Append(IntToStr(I));
        end;

        LQryCheckProv.SQL.Text :=
          'SELECT mp.id, COALESCE(NULLIF(mp.descripcion_trazabilidad, ''''), mp.descripcion) AS descripcion ' +
          'FROM ge_materias_primas mp ' +
          'WHERE mp.id IN (' + LIdsComma.ToString + ') ' +
          '  AND NOT EXISTS ( ' +
          '    SELECT 1 FROM ge_proveedores_materias_primas pmp ' +
          '    WHERE pmp.id_materia_prima = mp.id AND pmp.activo = 1 ' +
          '  ) ' +
          'ORDER BY descripcion ASC';
        LQryCheckProv.Open;
        while not LQryCheckProv.Eof do
        begin
          LMpSinProv.IdMateriaPrima := LQryCheckProv.FieldByName('id').AsInteger;
          LMpSinProv.Descripcion := LQryCheckProv.FieldByName('descripcion').AsString;
          if not LMpIdsGlobal.TryGetValue(LMpSinProv.IdMateriaPrima, LMpSinProv.Origen) then
            LMpSinProv.Origen := 'Receta';
          Result.SinProveedor.Add(LMpSinProv);
          LQryCheckProv.Next;
        end;
        LQryCheckProv.Close;
      finally
        LIdsComma.Free;
      end;

      if Result.SinProveedor.Count > 0 then
      begin
        Result.ParalizadoPorProveedores := True;
        Result.Exito := False;
        Result.MensajeResumen := Format(
          'PROCESO PARALIZADO: %d materia(s) prima(s) no tienen asignado ningún artículo de proveedor activo. ' +
          'Asigne los artículos de proveedor antes de continuar.',
          [Result.SinProveedor.Count]);
        Exit;
      end;
    end;

    // 4. PREPARAR QUERIES DE PROCESO PRINCIPAL Y POOL DE ENTRADAS
    LQryRec.Close;
    LQryRec.SQL.Text :=
      'SELECT pi.id_materia_prima, pi.unidad, SUM(pi.cantidad_base) AS cant_base ' +
      'FROM ob_recetas_procesos rp ' +
      'JOIN ob_procesos_ingredientes pi ON pi.proceso_id = rp.id ' +
      'WHERE rp.receta_id = :receta_id AND pi.tipo_origen = ''MP'' AND COALESCE(pi.en_trazabilidad, 1) = 1 ' +
      'GROUP BY pi.id_materia_prima, pi.unidad';

    LQryEnv.Close;
    LQryEnv.SQL.Text :=
      'SELECT fpm.id_materia_prima, ' +
      '       SUM(fpm.cantidad * COALESCE(NULLIF(se.cantidad_producida, 0), se.cantidad_unidades, 0)) AS cant_envase ' +
      'FROM ge_stock_envasado se ' +
      'JOIN ge_formatos_presentacion_materiales fpm ON fpm.id_formato_presentacion = se.id_formato_presentacion ' +
      'WHERE (se.id_lote = :lote_id ' +
      '       OR se.id_lote IN (SELECT rep.lote_inclusion_id FROM ob_elaboraciones_reparto rep ' +
      '                         WHERE rep.elaboracion_id = :elab_id AND rep.lote_inclusion_id IS NOT NULL)) ' +
      'GROUP BY fpm.id_materia_prima';

    LQryCons.Close;
    LQryCons.SQL.Text :=
      'SELECT id, id_materia_prima, cantidad, cantidad_teorica, cantidad_real, unidad ' +
      'FROM ob_lotes_consumidos ' +
      'WHERE elaboracion_id = :elab_id AND id_materia_prima IS NOT NULL ' +
      'ORDER BY id ASC';

    // Cargar pool de entradas FIFO
    LQryPool.SQL.Text :=
      'SELECT emp.id, COALESCE(NULLIF(emp.id_materia_prima, 0), pmp.id_materia_prima, 0) AS id_mp, emp.id_almacen, ' +
      '       COALESCE(emp.fecha_entrada, DATE(emp.created_at)) AS fecha_ent, ' +
      '       COALESCE(emp.lote, '''') AS lote, emp.cantidad_compra, emp.stock_restante ' +
      'FROM ge_entradas_materias_primas emp ' +
      'LEFT JOIN ge_proveedores_materias_primas pmp ON pmp.id = emp.id_articulo_proveedor ' +
      'WHERE emp.id_empresa = :emp ' +
      'ORDER BY COALESCE(emp.fecha_entrada, DATE(emp.created_at)) ASC, emp.id ASC';
    LQryPool.ParamByName('emp').AsInteger := AEmpresaId;
    LQryPool.Open;
    while not LQryPool.Eof do
    begin
      LEntry := TEntradaPoolItem.Create;
      LEntry.Id := LQryPool.FieldByName('id').AsInteger;
      LEntry.IdMateriaPrima := LQryPool.FieldByName('id_mp').AsInteger;
      LEntry.IdAlmacen := LQryPool.FieldByName('id_almacen').AsInteger;
      LEntry.FechaEntrada := LQryPool.FieldByName('fecha_ent').AsDateTime;
      LEntry.Lote := LQryPool.FieldByName('lote').AsString;
      LEntry.CantidadCompra := LQryPool.FieldByName('cantidad_compra').AsFloat;
      LEntry.Modificada := False;

      if LInvStockByEntrada.TryGetValue(LEntry.Id, LStockInv) then
      begin
        LEntry.StockActual := LStockInv;
        LEntry.Modificada := True;
      end
      else if LEntry.FechaEntrada > LFechaInicio then
      begin
        LEntry.StockActual := LEntry.CantidadCompra;
        LEntry.Modificada := True;
      end
      else
      begin
        LEntry.StockActual := 0.0;
        if Abs(LQryPool.FieldByName('stock_restante').AsFloat) > 0.0001 then
          LEntry.Modificada := True;
      end;

      LEntradasPool.Add(LEntry);
      if not LEntradasPorMP.TryGetValue(LEntry.IdMateriaPrima, LEntryList) then
      begin
        LEntryList := TList<TEntradaPoolItem>.Create;
        LEntradasPorMP.Add(LEntry.IdMateriaPrima, LEntryList);
      end;
      LEntryList.Add(LEntry);
      LQryPool.Next;
    end;
    LQryPool.Close;

    // Distribuir en FIFO inverso el stock del inventario por materia prima (inventarios sin id_entrada)
    for I in LInvStockByMP.Keys do
    begin
      LStockInv := LInvStockByMP[I];
      if (LStockInv > 0.0001) and LEntradasPorMP.TryGetValue(I, LEntryList) then
      begin
        LCantRestante := LStockInv;
        for K := LEntryList.Count - 1 downto 0 do
        begin
          if LEntryList[K].FechaEntrada <= LFechaInicio then
          begin
            if LEntryList[K].CantidadCompra >= LCantRestante then
            begin
              LEntryList[K].StockActual := LCantRestante;
              LCantRestante := 0.0;
            end
            else
            begin
              LEntryList[K].StockActual := LEntryList[K].CantidadCompra;
              LCantRestante := LCantRestante - LEntryList[K].CantidadCompra;
            end;
            LEntryList[K].Modificada := True;
            if LCantRestante <= 0.0001 then
              Break;
          end;
        end;
        if LCantRestante > 0.0001 then
        begin
          for K := LEntryList.Count - 1 downto 0 do
          begin
            if LEntryList[K].FechaEntrada <= LFechaInicio then
            begin
              LEntryList[K].StockActual := LEntryList[K].StockActual + LCantRestante;
              LEntryList[K].Modificada := True;
              Break;
            end;
          end;
        end;
      end;
    end;

    // 5. INICIAR TRANSACCIÓN (en simulación se hará Rollback al final)
    dmgMain.dbConn.StartTransaction;
    try
      LQryOrdenes.First;
      while not LQryOrdenes.Eof do
      begin
        LElabId := LQryOrdenes.FieldByName('id').AsInteger;
        LRecetaId := LQryOrdenes.FieldByName('id_receta').AsInteger;
        LLoteId := LQryOrdenes.FieldByName('lote_id').AsInteger;
        LMult := LQryOrdenes.FieldByName('multiplicador').AsFloat;
        if LMult <= 0.0001 then
          LMult := 1.0;

        LResOrden := Default(TResultadoOrden);
        LResOrden.ElaboracionId := LElabId;
        LResOrden.Fecha := LQryOrdenes.FieldByName('fecha').AsDateTime;
        LResOrden.LoteId := LLoteId;
        LResOrden.LoteCodigo := LQryOrdenes.FieldByName('lote_codigo').AsString;
        LResOrden.RecetaId := LRecetaId;
        LResOrden.RecetaDesc := LQryOrdenes.FieldByName('receta_desc').AsString;
        LResOrden.Multiplicador := LMult;
        LDetalleOrden := '';

        // 5A. Calcular materias primas esperadas (receta + envase)
        LExpectedMap.Clear;

        LQryRec.Close;
        LQryRec.ParamByName('receta_id').AsInteger := LRecetaId;
        LQryRec.Open;
        while not LQryRec.Eof do
        begin
          LCantBase := ConvertirAUnidadBase(
            LQryRec.FieldByName('cant_base').AsFloat * LMult,
            LQryRec.FieldByName('unidad').AsString,
            LUnidadBase);

          if LCantBase > 0.0001 then
          begin
            I := LQryRec.FieldByName('id_materia_prima').AsInteger;
            if not LExpectedMap.TryGetValue(I, LExpMP) then
            begin
              LExpMP := TExpectedMP.Create;
              LExpMP.IdMateriaPrima := I;
              LExpMP.CantidadBase := LCantBase;
              LExpMP.UnidadBase := LUnidadBase;
              LExpMP.EsReceta := True;
              LExpMP.EsEnvase := False;
              LExpectedMap.Add(I, LExpMP);
            end
            else if UnidadesCompatibles(LExpMP.UnidadBase, LUnidadBase) then
              LExpMP.CantidadBase := LExpMP.CantidadBase + LCantBase;
          end;
          LQryRec.Next;
        end;

        LQryEnv.Close;
        LQryEnv.ParamByName('lote_id').AsInteger := LLoteId;
        LQryEnv.ParamByName('elab_id').AsInteger := LElabId;
        LQryEnv.Open;
        while not LQryEnv.Eof do
        begin
          LCantEnv := LQryEnv.FieldByName('cant_envase').AsFloat;
          if LCantEnv > 0.0001 then
          begin
            I := LQryEnv.FieldByName('id_materia_prima').AsInteger;
            if not LExpectedMap.TryGetValue(I, LExpMP) then
            begin
              LExpMP := TExpectedMP.Create;
              LExpMP.IdMateriaPrima := I;
              LExpMP.CantidadBase := LCantEnv;
              LExpMP.UnidadBase := 'ud';
              LExpMP.EsReceta := False;
              LExpMP.EsEnvase := True;
              LExpectedMap.Add(I, LExpMP);
            end
            else
            begin
              LExpMP.CantidadBase := LExpMP.CantidadBase + LCantEnv;
              LExpMP.EsEnvase := True;
            end;
          end;
          LQryEnv.Next;
        end;

        // 5B. Comprobar y actualizar ob_lotes_consumidos contra lo esperado
        LConsList.Clear;
        LQryCons.Close;
        LQryCons.ParamByName('elab_id').AsInteger := LElabId;
        LQryCons.Open;
        while not LQryCons.Eof do
        begin
          LCons.Id := LQryCons.FieldByName('id').AsInteger;
          LCons.IdMateriaPrima := LQryCons.FieldByName('id_materia_prima').AsInteger;
          LCons.Cantidad := LQryCons.FieldByName('cantidad').AsFloat;
          LCons.CantidadTeorica := LQryCons.FieldByName('cantidad_teorica').AsFloat;
          LCons.CantidadReal := LQryCons.FieldByName('cantidad_real').AsFloat;
          LCons.Unidad := LQryCons.FieldByName('unidad').AsString;
          LConsList.Add(LCons);
          LQryCons.Next;
        end;

        LIdList := TList<Integer>.Create;
        try
          for I in LExpectedMap.Keys do
            LIdList.Add(I);

          for I := 0 to LIdList.Count - 1 do
          begin
            LExpMP := LExpectedMap[LIdList[I]];
            LTeoricaExistente := 0.0;
            LExistCount := 0;
            LFirstConsId := 0;
            LFirstConsUnidad := LExpMP.UnidadBase;

            for J := 0 to LConsList.Count - 1 do
            begin
              if LConsList[J].IdMateriaPrima = LExpMP.IdMateriaPrima then
              begin
                Inc(LExistCount);
                if LFirstConsId = 0 then
                begin
                  LFirstConsId := LConsList[J].Id;
                  LFirstConsUnidad := LConsList[J].Unidad;
                end;
                if LConsList[J].CantidadTeorica > 0.0001 then
                  LTeoricaExistente := LTeoricaExistente +
                    ConvertirAUnidadBase(LConsList[J].CantidadTeorica, LConsList[J].Unidad, LUnidadBase)
                else
                  LTeoricaExistente := LTeoricaExistente +
                    ConvertirAUnidadBase(LConsList[J].Cantidad, LConsList[J].Unidad, LUnidadBase);
              end;
            end;

            if LExistCount = 0 then
            begin
              LQryExec.Close;
              LQryExec.SQL.Text :=
                'INSERT INTO ob_lotes_consumidos ' +
                '  (elaboracion_id, id_materia_prima, cantidad, cantidad_teorica, cantidad_real, unidad, id_user_creator) ' +
                'VALUES (:elab, :mp, :cant, :cant, 0.0, :unidad, :usr)';
              LQryExec.ParamByName('elab').AsInteger := LElabId;
              LQryExec.ParamByName('mp').AsInteger := LExpMP.IdMateriaPrima;
              LQryExec.ParamByName('cant').AsFloat := LExpMP.CantidadBase;
              LQryExec.ParamByName('unidad').AsString := LExpMP.UnidadBase;
              LQryExec.ParamByName('usr').AsInteger := AUsuarioId;
              LQryExec.ExecSQL;

              if LExpMP.EsEnvase and not LExpMP.EsReceta then
                Inc(LResOrden.EnvasesInsertados)
              else
                Inc(LResOrden.IngredientesInsertados);
            end
            else if (LExistCount = 1) and (Abs(LTeoricaExistente - LExpMP.CantidadBase) > 0.005) then
            begin
              LCantConsumir := ConvertirDesdeUnidadBase(LExpMP.CantidadBase, LFirstConsUnidad);
              LQryExec.Close;
              LQryExec.SQL.Text :=
                'UPDATE ob_lotes_consumidos SET ' +
                '  cantidad_teorica = :cant, ' +
                '  cantidad = CASE WHEN cantidad_real <= 0.0001 THEN :cant ELSE cantidad END, ' +
                '  id_user_update = :usr ' +
                'WHERE id = :id';
              LQryExec.ParamByName('cant').AsFloat := LCantConsumir;
              LQryExec.ParamByName('usr').AsInteger := AUsuarioId;
              LQryExec.ParamByName('id').AsInteger := LFirstConsId;
              LQryExec.ExecSQL;

              if LExpMP.EsEnvase and not LExpMP.EsReceta then
                Inc(LResOrden.EnvasesActualizados)
              else
                Inc(LResOrden.IngredientesActualizados);
            end;
          end;
        finally
          LIdList.Free;
        end;

        // 5C. Releer consumos de la orden y asignar lotes FIFO desde stock positivo
        LConsList.Clear;
        LQryCons.Close;
        LQryCons.ParamByName('elab_id').AsInteger := LElabId;
        LQryCons.Open;
        while not LQryCons.Eof do
        begin
          LCons.Id := LQryCons.FieldByName('id').AsInteger;
          LCons.IdMateriaPrima := LQryCons.FieldByName('id_materia_prima').AsInteger;
          LCons.Cantidad := LQryCons.FieldByName('cantidad').AsFloat;
          LCons.CantidadTeorica := LQryCons.FieldByName('cantidad_teorica').AsFloat;
          LCons.CantidadReal := LQryCons.FieldByName('cantidad_real').AsFloat;
          LCons.Unidad := LQryCons.FieldByName('unidad').AsString;
          LConsList.Add(LCons);
          LQryCons.Next;
        end;

        for J := 0 to LConsList.Count - 1 do
        begin
          LCons := LConsList[J];
          if LCons.CantidadReal > 0.0001 then
            LCantConsumir := LCons.CantidadReal
          else if LCons.CantidadTeorica > 0.0001 then
            LCantConsumir := LCons.CantidadTeorica
          else
            LCantConsumir := LCons.Cantidad;

          LCantBase := ConvertirAUnidadBase(LCantConsumir, LCons.Unidad, LUnidadBase);
          if LCantBase <= 0.0001 then
            Continue;

          // Buscar entradas con StockActual > 0 al momento de esta orden
          LEligibleList.Clear;
          if LEntradasPorMP.TryGetValue(LCons.IdMateriaPrima, LEntryList) then
          begin
            LHaveDateMatch := False;
            for K := 0 to LEntryList.Count - 1 do
            begin
              if (LEntryList[K].StockActual > 0.0001) and (LEntryList[K].FechaEntrada <= LResOrden.Fecha) then
              begin
                LEligibleList.Add(LEntryList[K]);
                LHaveDateMatch := True;
              end;
            end;
            if not LHaveDateMatch then
            begin
              for K := 0 to LEntryList.Count - 1 do
              begin
                if LEntryList[K].StockActual > 0.0001 then
                  LEligibleList.Add(LEntryList[K]);
              end;
            end;
          end;

          if LEligibleList.Count = 0 then
          begin
            LResOrden.SinStockPositivo := True;
            if LDetalleOrden <> '' then LDetalleOrden := LDetalleOrden + '; ';
            LDetalleOrden := LDetalleOrden + Format('Sin entrada con stock > 0 para MP #%d', [LCons.IdMateriaPrima]);
            Continue;
          end;

          LCantRestante := LCantBase;
          for K := 0 to LEligibleList.Count - 1 do
          begin
            LBestEntry := LEligibleList[K];
            // Si es la última entrada elegible o cubre el resto, se asigna todo lo restante
            // (permitiendo que quede en negativo SOLO durante esta orden; en la siguiente ya no será > 0).
            if (K = LEligibleList.Count - 1) or (LBestEntry.StockActual >= LCantRestante - 0.0001) then
              LUsedBase := LCantRestante
            else
              LUsedBase := LBestEntry.StockActual;

            LBestEntry.StockActual := LBestEntry.StockActual - LUsedBase;
            LBestEntry.Modificada := True;
            if LBestEntry.StockActual < -0.0001 then
            begin
              LResOrden.TuvoStockNegativo := True;
              if LDetalleOrden <> '' then LDetalleOrden := LDetalleOrden + '; ';
              LDetalleOrden := LDetalleOrden + Format('Lote %s queda en %.3f', [LBestEntry.Lote, LBestEntry.StockActual]);
            end;

            LUnidadDest := LCons.Unidad;
            if Trim(LUnidadDest) = '' then
              LUnidadDest := LUnidadBase;

            if K = 0 then
            begin
              LQryExec.Close;
              LQryExec.SQL.Text :=
                'UPDATE ob_lotes_consumidos SET ' +
                '  lote_consumido_id = :emp_id, ' +
                '  lote_real = :lote, ' +
                '  cantidad = :cant, ' +
                '  cantidad_teorica = CASE WHEN :es_div = 1 THEN :cant ELSE cantidad_teorica END, ' +
                '  cantidad_real = CASE WHEN cantidad_real > 0 THEN :cant ELSE cantidad_real END, ' +
                '  id_user_update = :usr ' +
                'WHERE id = :id';
              LQryExec.ParamByName('emp_id').AsInteger := LBestEntry.Id;
              LQryExec.ParamByName('lote').AsString := LBestEntry.Lote;
              LQryExec.ParamByName('cant').AsFloat := ConvertirDesdeUnidadBase(LUsedBase, LUnidadDest);
              if (K < LEligibleList.Count - 1) and (LUsedBase < LCantBase - 0.0001) then
                LQryExec.ParamByName('es_div').AsInteger := 1
              else
                LQryExec.ParamByName('es_div').AsInteger := 0;
              LQryExec.ParamByName('usr').AsInteger := AUsuarioId;
              LQryExec.ParamByName('id').AsInteger := LCons.Id;
              LQryExec.ExecSQL;
              Inc(LResOrden.LotesAsignados);
            end
            else
            begin
              LQryExec.Close;
              LQryExec.SQL.Text :=
                'INSERT INTO ob_lotes_consumidos ' +
                '  (elaboracion_id, id_materia_prima, lote_consumido_id, lote_real, cantidad, cantidad_teorica, cantidad_real, unidad, id_user_creator) ' +
                'VALUES (:elab, :mp, :emp_id, :lote, :cant, :cant, :cant_real, :unidad, :usr)';
              LQryExec.ParamByName('elab').AsInteger := LElabId;
              LQryExec.ParamByName('mp').AsInteger := LCons.IdMateriaPrima;
              LQryExec.ParamByName('emp_id').AsInteger := LBestEntry.Id;
              LQryExec.ParamByName('lote').AsString := LBestEntry.Lote;
              LQryExec.ParamByName('cant').AsFloat := ConvertirDesdeUnidadBase(LUsedBase, LUnidadDest);
              if LCons.CantidadReal > 0.0001 then
                LQryExec.ParamByName('cant_real').AsFloat := ConvertirDesdeUnidadBase(LUsedBase, LUnidadDest)
              else
                LQryExec.ParamByName('cant_real').AsFloat := 0.0;
              LQryExec.ParamByName('unidad').AsString := LUnidadDest;
              LQryExec.ParamByName('usr').AsInteger := AUsuarioId;
              LQryExec.ExecSQL;
              Inc(LResOrden.LotesAsignados);
              Inc(LResOrden.LotesDivididos);
            end;

            LCantRestante := LCantRestante - LUsedBase;
            if LCantRestante <= 0.0001 then
              Break;
          end;
        end;

        // Estado final de la orden
        if LResOrden.SinStockPositivo then
          LResOrden.Estado := 'SIN_STOCK'
        else if LResOrden.TuvoStockNegativo then
          LResOrden.Estado := 'AVISO_NEGATIVO'
        else if (LResOrden.IngredientesInsertados + LResOrden.IngredientesActualizados +
                 LResOrden.EnvasesInsertados + LResOrden.EnvasesActualizados) > 0 then
          LResOrden.Estado := 'ACTUALIZADO'
        else
          LResOrden.Estado := 'OK';

        if LDetalleOrden = '' then
          LDetalleOrden := Format('Lotes asignados: %d', [LResOrden.LotesAsignados]);
        LResOrden.Detalle := LDetalleOrden;

        Result.Ordenes.Add(LResOrden);
        Inc(Result.TotalOrdenes);
        Inc(Result.TotalIngInsertados, LResOrden.IngredientesInsertados);
        Inc(Result.TotalIngActualizados, LResOrden.IngredientesActualizados);
        Inc(Result.TotalEnvInsertados, LResOrden.EnvasesInsertados);
        Inc(Result.TotalEnvActualizados, LResOrden.EnvasesActualizados);
        Inc(Result.TotalLotesAsignados, LResOrden.LotesAsignados);
        if LResOrden.TuvoStockNegativo then
          Inc(Result.TotalOrdenesConNegativo);
        if LResOrden.SinStockPositivo then
          Inc(Result.TotalOrdenesSinStockPositivo);

        LQryOrdenes.Next;
      end;

      // 6. Actualizar stock_restante en ge_entradas_materias_primas
      for I := 0 to LEntradasPool.Count - 1 do
      begin
        LEntry := LEntradasPool[I];
        if LEntry.Modificada then
        begin
          LQryExec.Close;
          LQryExec.SQL.Text :=
            'UPDATE ge_entradas_materias_primas SET ' +
            '  stock_restante = :stock, id_user_update = :usr ' +
            'WHERE id = :id';
          LQryExec.ParamByName('stock').AsFloat := LEntry.StockActual;
          LQryExec.ParamByName('usr').AsInteger := AUsuarioId;
          LQryExec.ParamByName('id').AsInteger := LEntry.Id;
          LQryExec.ExecSQL;
        end;
      end;

      if ASimular then
        dmgMain.dbConn.Rollback
      else
        dmgMain.dbConn.Commit;

      Result.Exito := True;
      if ASimular then
        Result.MensajeResumen := Format(
          'SIMULACIÓN COMPLETADA (%d órdenes desde %s): %d lotes a asignar, %d ing. añadidos, %d env. añadidos. ' +
          'Órdenes con stock negativo: %d | Sin stock positivo: %d.',
          [Result.TotalOrdenes, FormatDateTime('dd/mm/yyyy', LFechaInicio),
           Result.TotalLotesAsignados, Result.TotalIngInsertados, Result.TotalEnvInsertados,
           Result.TotalOrdenesConNegativo, Result.TotalOrdenesSinStockPositivo])
      else
        Result.MensajeResumen := Format(
          'PROCESO COMPLETADO (%d órdenes desde %s): %d lotes asignados, %d ing. añadidos, %d env. añadidos. ' +
          'Órdenes con stock negativo: %d | Sin stock positivo: %d.',
          [Result.TotalOrdenes, FormatDateTime('dd/mm/yyyy', LFechaInicio),
           Result.TotalLotesAsignados, Result.TotalIngInsertados, Result.TotalEnvInsertados,
           Result.TotalOrdenesConNegativo, Result.TotalOrdenesSinStockPositivo]);
    except
      on E: Exception do
      begin
        if dmgMain.dbConn.InTransaction then
          dmgMain.dbConn.Rollback;
        Result.Exito := False;
        Result.MensajeResumen := 'Error durante el proceso: ' + E.Message;
        TDbErrorHandler.HandleException(E, 'Regularizar lotes de fabricación');
      end;
    end;
  finally
    for I in LEntradasPorMP.Keys do
      LEntradasPorMP[I].Free;
    LEntradasPorMP.Free;
    LEntradasPool.Free;
    LExpectedMap.Free;
    LMpIdsGlobal.Free;
    LMpDescMap.Free;
    LInvStockByEntrada.Free;
    LInvStockByMP.Free;
    LConsList.Free;
    LEligibleList.Free;

    LQryInv.Free;
    LQryOrdenes.Free;
    LQryRec.Free;
    LQryEnv.Free;
    LQryCons.Free;
    LQryCheckProv.Free;
    LQryPool.Free;
    LQryExec.Free;
  end;
end;

end.
