unit ueditarfuentesmultientradas;

  {$MODE Delphi}

interface

uses
  {$IFDEF WINDOWS}
  Windows,
  {$ELSE}
  LCLType,
  {$ENDIF}
  SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Grids, ComCtrls, ExtCtrls, Buttons, Menus,
  ucosa,
  uBaseEditoresFuentesConFichas,
  uCosaConNombre,
  uFuentesAleatorias,
  uFuenteConstante,
  usalasdejuego,
  utilidades,
  uEditarBorne, uConstantesSimSEE, uverdoc,
  uopencalcexportimport,
  ufuenteoperacionmultifuente,
  uAuxiliares, Types,
  uresourcestring;

resourcestring
  rsNombreDelBorne = 'Nombre del Borne';
  mesConfirmaEliminarBorne = '¿Confirma que desea eliminar el borne seleccionado?';
  mesConfirmarEliminacion = 'Confirmar eliminación';

  mesConfirmaEliminarEntrada = '¿Confirma que desea eliminar la entrada seleccionada?';
  rsNombreDeEntrada = 'Entrada';
  rsNombreDeFuenteBorne = 'Fuente.Borne';

type

  { TEditarFuentesMultiEntradas }

  TEditarFuentesMultiEntradas = class(TBaseEditoresFuentesConFichas)
    BAgregarBorne: TButton;
    btAgregarFicha: TButton;
    btAgregarEntrada: TButton;
    btExportar_ods: TButton;
    btImportar_ods: TButton;
    btVerExpandida: TButton;
    cbFuentes: TComboBox;
    cbBorne: TComboBox;
    ENombre: TEdit;
    gbEntradas: TGroupBox;
    gbSalidas: TGroupBox;
    gbFichasDinamicas: TGroupBox;
    eNombreVar: TLabeledEdit;
    LFichasLPD: TLabel;
    LNombre: TLabel;
    Panel1: TPanel;
    sgBornes: TStringGrid;
    BGuardar: TButton;
    BCancelar: TButton;
    LDurPasoSorteo: TLabel;
    EdurPasoSorteo: TEdit;
    BAyuda: TButton;
    cbResumirPromediando: TCheckBox;
    sgEntradas: TStringGrid;
    sgFichas: TStringGrid;
    procedure btAgregarFichaClick(Sender: TObject);
    procedure BExportarAEXCELClick(Sender: TObject);
    procedure BImportarDesdeExcelClick(Sender: TObject);
    procedure btAgregarEntradaClick(Sender: TObject);
    procedure btVerExpandidaClick(Sender: TObject);
    procedure cbBorneChange(Sender: TObject);
    procedure cbFuentesChange(Sender: TObject);
    procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
    procedure FormCloseQuery(Sender: TObject; var CanClose: boolean);
    procedure BCancelarClick(Sender: TObject);
    procedure EditEnter(Sender: TObject);
    procedure l(Sender: TObject; ACol, ARow: integer;
      Rect: TRect; State: TGridDrawState);
    procedure sgBornesMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: integer);
    procedure sgBornesMouseMove(Sender: TObject; Shift: TShiftState; X, Y: integer);
    procedure sgBornesMouseUp(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: integer);
    procedure BAgregarBorneClick(Sender: TObject);
    procedure BGuardarClick(Sender: TObject); override;
    procedure BAyudaClick(Sender: TObject);
    procedure EditIntExit(Sender: TObject);
    procedure cambiosForm(Sender: TObject);
    procedure ENombreExit(Sender: TObject);
    procedure sgEntradasDrawCell(Sender: TObject; aCol, aRow: Integer;
      aRect: TRect; aState: TGridDrawState);
    procedure sgEntradasMouseMove(Sender: TObject; Shift: TShiftState; X,
      Y: Integer);
    procedure sgEntradasMouseUp(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);


  private
    FuentesEntradas: TListaDeCosas;
    NombresEntradas: TStringList;

    NombresDeBornes_Publicados: TStringList;
    tiposColBornes: TDAOfTTipoColumna;
    tiposColEntradas: TDAOfTTipoColumna;
    sala: TSalaDeJuego;
  public

    procedure editarBorne(fila: integer);
    procedure eliminarBorne(fila: integer);
    procedure eliminarEntrada(fila: integer);

    procedure actualizarTablaBornes;
    procedure actualizarTablaEntradas;

  protected
    function validarFormulario: boolean; override;
  public
    constructor Create(AOwner: TComponent; sala: TSalaDeJuego;
      tipoCosa: TClass; cosaConNombre: TCosaConNombre); override;
  end;

implementation

  {$R *.lfm}


constructor TEditarFuentesMultiEntradas.Create(AOwner: TComponent;
  sala: TSalaDeJuego; tipoCosa: TClass; cosaConNombre: TCosaConNombre);
var
  k, i: integer;
  fuente: TFuenteOperacionMultiFuente;
begin
  inherited Create(AOwner, sala, tipoCosa, cosaConNombre);

  self.sala:= sala;

  utilidades.initListado(sgBornes, [rsNombreDelBorne, encabezadoBTEditar,
    encabezadoBTEliminar], tiposColBornes, True);

  utilidades.initListado(sgEntradas, [rsNombreDeFuenteBorne, rsNombreDeEntrada,
    encabezadoBTEliminar], tiposColEntradas, True);


  sgLimpiarSeleccion(sgBornes);

  self.NombresEntradas := TStringList.Create;

  // por ahora solo sabe exportar e importar bien las constantes
  if tipoCosa = TFuenteConstante then
  begin
    btExportar_ods.Visible := True;
    btImportar_ods.Visible := True;
  end
  else
  begin
    btExportar_ods.Visible := False;
    btImportar_ods.Visible := False;
  end;

  if cosaConNombre <> nil then
  begin
    fuente := TFuenteOperacionMultiFuente(cosaConNombre);
    inicializarComponentesLPD(fuente.lpd, TClaseDeFuenteAleatoriaConFichas(
      tipoCosa).TipoFichaFuente, sgFichas,
      self.btAgregarFicha, btVerExpandida, BGuardar, BCancelar);

    ENombre.Text := fuente.nombre;
    EdurPasoSorteo.Text := IntToStr(fuente.durPasoDeSorteoEnHoras);
    self.cbResumirPromediando.Checked := fuente.ResumirPromediando;

    NombresDeBornes_Publicados := TStringList.Create;
    for i := 0 to fuente.NombresDeBornes_Publicados.Count - 1 do
      NombresDeBornes_Publicados.Add(fuente.NombresDeBornes_Publicados[i]);

    for i := 0 to fuente.Entradas_Nombres.Count - 1 do
      self.NombresEntradas.add(fuente.Entradas_Nombres[i]);

    if fuente.Entradas_FuenteBorne <> nil then
      self.FuentesEntradas := rbtEditorSala.Clonar_Y_ResolverReferencias(fuente.Entradas_FuenteBorne) as
        TListaDeCosas
    else
        self.FuentesEntradas := TListaDeCosas.Create( 0, 'lstFuentesEntrada' );

    actualizarTablaBornes;
    actualizarTablaEntradas;
  end
  else
  begin
    inicializarComponentesLPD(nil, TClaseDeFuenteAleatoriaConFichas(
      tipoCosa).TipoFichaFuente, sgFichas,
      btAgregarFicha, btVerExpandida, BGuardar, BCancelar);

    NombresDeBornes_Publicados := TStringList.Create;
    NombresDeBornes_Publicados.Add( rsBorne );
    self.FuentesEntradas := TListaDeCosas.Create( 0, 'lstFuentesEntrada' );

    actualizarTablaBornes;
    actualizarTablaEntradas;
  end;

  // lleando del listado de fuentes.
  for k:= 0 to sala.listaFuentes_.Count-1 do
    cbFuentes.Items.add( sala.listaFuentes_[k].nombre );
end;


procedure TEditarFuentesMultiEntradas.ENombreExit(Sender: TObject);
begin
  inherited validarNombre(Sender);
end;

procedure TEditarFuentesMultiEntradas.sgEntradasDrawCell(Sender: TObject; aCol,
  aRow: Integer; aRect: TRect; aState: TGridDrawState);
begin
  utilidades.ListadoDrawCell(Sender, ACol, ARow, aRect, aState,
    tiposColEntradas[ACol], nil, iconos);
end;

procedure TEditarFuentesMultiEntradas.sgEntradasMouseMove(Sender: TObject;
  Shift: TShiftState; X, Y: Integer);
begin
  utilidades.ListadoMouseMove(Sender, Shift, X, Y, tiposColEntradas);
end;

procedure TEditarFuentesMultiEntradas.sgEntradasMouseUp(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
  res: TTipoColumna;
begin
  res := utilidades.ListadoMouseUp(Sender, Button, Shift, X, Y, tiposColEntradas);
  case res of
//    TC_btEditar: editarBorne(TStringGrid(Sender).Row);
    TC_btEliminar: eliminarEntrada(TStringGrid(Sender).Row);
  end;
end;

procedure TEditarFuentesMultiEntradas.editarBorne(fila: integer);
var
  form: TEditarBorne;
begin
  form := TEditarBorne.Create(self, NombresDeBornes_Publicados, fila - 1);
  if form.ShowModal = mrOk then
  begin
    if fila - 1 < NombresDeBornes_Publicados.Count then
      NombresDeBornes_Publicados[fila - 1] := form.darBorne
    else
      NombresDeBornes_Publicados.add(form.darBorne);
    actualizarTablaBornes;
    modificado:= true;
  end;
  form.Free;
end;

procedure TEditarFuentesMultiEntradas.eliminarBorne(fila: integer);
begin
  if (Application.MessageBox(PChar(mesConfirmaEliminarBorne),
    PChar(mesConfirmarEliminacion), MB_OKCANCEL + MB_ICONEXCLAMATION) = idOk) then
  begin
    NombresDeBornes_Publicados.Delete(fila - 1);
    actualizarTablaBornes;
  end;
end;

procedure TEditarFuentesMultiEntradas.eliminarEntrada(fila: integer);
begin
  if (Application.MessageBox(PChar(mesConfirmaEliminarEntrada),
    PChar(mesConfirmarEliminacion), MB_OKCANCEL + MB_ICONEXCLAMATION) = idOk) then
  begin
    NombresEntradas.Delete( fila - 1);
    TFuenteAleatoria_Borne( FuentesEntradas.items[ fila - 1 ] ).Free;
    FuentesEntradas.Delete( fila - 1);
    actualizarTablaEntradas;
  end;

end;

procedure TEditarFuentesMultiEntradas.actualizarTablaBornes;
var
  i: integer;
begin
  sgBornes.RowCount := NombresDeBornes_Publicados.Count + 1;
  if sgBornes.RowCount > 1 then
    sgBornes.FixedRows := 1;

  for i := 0 to NombresDeBornes_Publicados.Count - 1 do
    sgBornes.Cells[0, i + 1] := NombresDeBornes_Publicados[i];

  for i := 0 to sgBornes.ColCount - 1 do
    utilidades.AutoSizeTypedCol(sgBornes, i, TiposColBornes[i], iconos);
  BAgregarBorne.Left := (sgBornes.Left + sgBornes.Width) - BAgregarBorne.Width;
end;

procedure TEditarFuentesMultiEntradas.actualizarTablaEntradas;
var
  i: integer;
  aFB: TFuenteAleatoria_Borne;

begin
  sgEntradas.RowCount := Self.NombresEntradas.Count + 1;
  if sgEntradas.RowCount > 1 then
    sgEntradas.FixedRows := 1;

  for i := 0 to NombresEntradas.Count - 1 do
  begin
    aFB := FuentesEntradas[i] as TFuenteAleatoria_Borne;
    sgEntradas.Cells[0, i + 1] := aFB.fuente.nombre + '.' + aFB.borne;
    sgEntradas.Cells[1, i + 1] := NombresEntradas[i];
  end;

  for i := 0 to sgEntradas.ColCount - 1 do
    utilidades.AutoSizeTypedCol(sgEntradas, i, TiposColEntradas[i], iconos);
  BAgregarBorne.Left := (sgBornes.Left + sgBornes.Width) - BAgregarBorne.Width;
end;

function TEditarFuentesMultiEntradas.validarFormulario: boolean;
begin
  Result := inherited validarFormulario and inherited validarNombre(ENombre) and
    inherited validarEditInt(EdurPasoSorteo, 0, MAXINT);
end;

procedure TEditarFuentesMultiEntradas.FormCloseQuery(Sender: TObject;
  var CanClose: boolean);
begin
  inherited FormCloseQuery(Sender, CanClose);
  if CanClose and (ModalResult <> mrOk) then
    NombresDeBornes_Publicados.Free;
end;

procedure TEditarFuentesMultiEntradas.btAgregarFichaClick(Sender: TObject);
begin
  inherited procAgregarFichaClick(Sender);
end;

procedure TEditarFuentesMultiEntradas.BExportarAEXCELClick(Sender: TObject);
begin
  if lpd_.Count = 0 then
    exit;
  uopencalcexportimport.exportar_FichasLPD_aODS(lpd_, btExportar_ods, btImportar_ods);
end;

procedure TEditarFuentesMultiEntradas.BImportarDesdeExcelClick(Sender: TObject);
begin
  if lpd_.Count = 0 then
    exit;
  uopencalcexportimport.importar_FichasLPD_DesdeODS(
    lpd_, sala.evaluador, btExportar_ods, btImportar_ods);
  ActualizarTabla;
end;

procedure TEditarFuentesMultiEntradas.btAgregarEntradaClick(Sender: TObject);
var
  aFB: TFuenteAleatoria_Borne;
  k, j: integer;
  nombreVar: string;
  cntRep: integer;
begin
  k:= cbFuentes.ItemIndex;
  if k >= 0 then
  begin
    aFB:= TFuenteAleatoria_Borne.Create(0, sala.listaFuentes_[k] as TFuenteAleatoria, cbBorne.Text );
    FuentesEntradas.add( aFB );
    nombreVar:= eNombreVar.text;
    cntRep:= 0;
    while NombresEntradas.IndexOf( nombreVar ) >= 0 do
    begin
      inc( cntRep );
      nombreVar:= eNombreVar.text+ IntToStr( cntRep );
    end;

    NombresEntradas.Add( nombreVar );
  end;
  actualizarTablaEntradas;
  modificado:= true;

end;

procedure TEditarFuentesMultiEntradas.btVerExpandidaClick(Sender: TObject);
begin
  inherited;
end;

procedure TEditarFuentesMultiEntradas.cbBorneChange(Sender: TObject);
var
  k, j: integer;
  af: TFuenteAleatoria;
begin
  k:= cbFuentes.ItemIndex;
  if k >= 0 then
  begin
    j:= cbBorne.ItemIndex;
    if j > 0 then
    begin
      af:= sala.listaFuentes_[k] as TFuenteAleatoria;
      eNombreVar.Text:= PurificarAlfaNum(af.nombre)+'.'+ PurificarAlfaNum( af.NombresDeBornes_Publicados[j] );
    end;
  end;
end;

procedure TEditarFuentesMultiEntradas.cbFuentesChange(Sender: TObject);
var
  k, j: integer;
  af: TFuenteAleatoria;
begin
  k:= cbFuentes.ItemIndex;
  if k >= 0 then
  begin
    cbBorne.Clear;
    af:= sala.listaFuentes_[k] as TFuenteAleatoria;
    for j:= 0 to af.NombresDeBornes_Publicados.count-1 do
      cbBorne.items.add( af.NombresDeBornes_Publicados[j] );
    cbBorne.ItemIndex:= 0;
    eNombreVar.Text:= af.nombre+'.'+af.NombresDeBornes_Publicados[0];
  end;
end;

procedure TEditarFuentesMultiEntradas.FormClose(Sender: TObject;
  var CloseAction: TCloseAction);
begin
  inherited FormClose(Sender, CloseACtion);
end;

procedure TEditarFuentesMultiEntradas.BCancelarClick(Sender: TObject);
begin
  inherited BCancelarClick(Sender);
end;

procedure TEditarFuentesMultiEntradas.EditEnter(Sender: TObject);
begin
  inherited EditEnter(Sender);
end;

procedure TEditarFuentesMultiEntradas.EditIntExit(Sender: TObject);
begin
  inherited EditIntExit(Sender, 0, MaxInt);
end;

procedure TEditarFuentesMultiEntradas.l(Sender: TObject;
  ACol, ARow: integer; Rect: TRect; State: TGridDrawState);
begin
  utilidades.ListadoDrawCell(Sender, ACol, ARow, Rect, State,
    tiposColBornes[ACol], nil, iconos);
end;

procedure TEditarFuentesMultiEntradas.sgBornesMouseDown(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: integer);
begin
  utilidades.ListadoMouseDown(Sender, Button, Shift, X, Y);
end;

procedure TEditarFuentesMultiEntradas.sgBornesMouseMove(Sender: TObject;
  Shift: TShiftState; X, Y: integer);
begin
  utilidades.ListadoMouseMove(Sender, Shift, X, Y, tiposColBornes);
end;

procedure TEditarFuentesMultiEntradas.sgBornesMouseUp(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: integer);
var
  res: TTipoColumna;
begin
  res := utilidades.ListadoMouseUp(Sender, Button, Shift, X, Y, tiposColBornes);
  case res of
    TC_btEditar: editarBorne(TStringGrid(Sender).Row);
    TC_btEliminar: eliminarBorne(TStringGrid(Sender).Row);
  end;
end;

procedure TEditarFuentesMultiEntradas.BAgregarBorneClick(Sender: TObject);
begin
  editarBorne(NombresDeBornes_Publicados.Count + 1);
end;

procedure TEditarFuentesMultiEntradas.BGuardarClick(Sender: TObject);
var
  fuente: TFuenteOperacionMultiFuente;

begin
  if validarFormulario then
  begin
    if cosaConNombre = nil then
    begin
      cosaConNombre := TFuenteOperacionMultiFuente.Create(capa,
        ENombre.Text, StrToInt(EdurPasoSorteo.Text),
        self.cbResumirPromediando.Checked, lpd_);
    end
    else
    begin
      fuente := TFuenteOperacionMultiFuente(cosaConNombre);
      fuente.nombre := ENombre.Text;
      fuente.durPasoDeSorteoEnHoras := StrToInt(EdurPasoSorteo.Text);
      fuente.ResumirPromediando := cbResumirPromediando.Checked;

      fuente.lpd.Free;
      fuente.lpd := lpd_;
    end;
    TFuenteOperacionMultiFuente(cosaConNombre).NombresDeBornes_Publicados.Free;
    TFuenteOperacionMultiFuente(cosaConNombre).NombresDeBornes_Publicados := NombresDeBornes_Publicados;

    TFuenteOperacionMultiFuente(cosaConNombre).Entradas_Nombres.Free;
    TFuenteOperacionMultiFuente(cosaConNombre).Entradas_Nombres:= self.NombresEntradas;

    TFuenteOperacionMultiFuente(cosaConNombre).Entradas_FuenteBorne.Free;
    TFuenteOperacionMultiFuente(cosaConNombre).Entradas_FuenteBorne:= self.FuentesEntradas;

    setlength( TFuenteOperacionMultiFuente(cosaConNombre).Bornera,  NombresDeBornes_Publicados.count );
    TFuenteOperacionMultiFuente(cosaConNombre).PubliVars;

    ModalResult := mrOk;
  end;
end;

procedure TEditarFuentesMultiEntradas.cambiosForm(Sender: TObject);
begin
  inherited cambiosForm(Sender);
end;


procedure TEditarFuentesMultiEntradas.BAyudaClick(Sender: TObject);
begin
  verdoc( 3827, tipoCosa);
end;

end.
