AsientoPredefinidoGestorDeVariables.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using sage.ew.global;
using sage.ew.interficies;

namespace sage.ew.contabilidad
{
    internal class AsientoPredefinidoGestorDeVariablesImpl : IAsientoPredefinidoGestorDeVariables
    {
        #region Variables

        readonly AsientosPredefinidosGenerador generadorDePredefinidos;

        private readonly bool _trabajaConSeriesDeFactura = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_serfact"));

        #endregion Variables

        #region Constructores

        private AsientoPredefinidoGestorDeVariablesImpl() { }

        public AsientoPredefinidoGestorDeVariablesImpl(AsientosPredefinidosGenerador toGenerador)
        {
            generadorDePredefinidos = toGenerador;
        }

        #endregion Constructores

        #region Métodos públicos

        #region Nombres de variables

        public IEnumerable<string> _ObtenerNombresDeVariablesTodos()
        {
            return obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.Todas);
        }

        public IEnumerable<string> _ObtenerNombresDeVariablesColumnaCuenta()
        {
            return obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloPropiedadCuenta);
        }

        public IEnumerable<string> _ObtenerNombresDeVariablesColumnaRelacion()
        {
            return obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloPropiedadRelacion);
        }

        public IEnumerable<string> _ObtenerNombresDeVariablesColumnaCuentaAsignacion()
        {
            return obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloPropiedadCtaAsignacion);
        }

        public IEnumerable<string> _ObtenerNombresDeVariablesDeTipoCuenta()
        {
            return obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloCuentas);
        }

        public IEnumerable<string> _ObtenerNombresDeVariablesDeTipoVariable()
        {
            return obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloVariables);
        }

        public IEnumerable<string> _ObtenerNombresDeVariablesDebeHaber()
        {
            return obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloVariables);
        }

        #endregion Nombres de variables

        #region IVaribleAsientoPredefinido

        public IEnumerable<IAsientoPredefinidoVarible> _ObtenerVariablesDeTipoCuenta()
        {
            return obtenerVariablesFiltradasPor(TipoFiltroVariables.SoloCuentas);
        }

        public IEnumerable<IAsientoPredefinidoVarible> _ObtenerVariablesDeTipoVariable()
        {
            return obtenerVariablesFiltradasPor(TipoFiltroVariables.SoloVariables);
        }

        public IEnumerable<IAsientoPredefinidoVarible> _ObtenerVariablesColumnaRelacion()
        {
            return obtenerVariablesFiltradasPor(TipoFiltroVariables.SoloPropiedadRelacion);
        }

        public IEnumerable<IAsientoPredefinidoVarible> _ObtenerVariablesColumnaCuentaAsignacion()
        {
            return obtenerVariablesFiltradasPor(TipoFiltroVariables.SoloPropiedadCtaAsignacion);
        }


        public IEnumerable<IAsientoPredefinidoVarible> _ObtenerVariablesColumnaDebeHaber()
        {
            return obtenerVariablesFiltradasPor(TipoFiltroVariables.SoloDebeHaber);
        }

        #endregion IVaribleAsientoPredefinido

        public void _EstablecerVariables(Dictionary<string, string> tdicValores)
        {
            foreach (var lineaAsientoPredef in generadorDePredefinidos._LineasAsientoPredefinido)
            {
                lineaAsientoPredef._EstablecerVariables(tdicValores);
            }
        }

        public void _EstablecerVariablesDebeHaber(Dictionary<string, string> tdicValores)
        {
            foreach (var lineaAsientoPredef in generadorDePredefinidos._LineasAsientoPredefinido)
            {
                lineaAsientoPredef._EstablecerVariablesDebeHaber(tdicValores);
            }
        }

        public void _EstablecerVariables(IEnumerable<IAsientoPredefinidoVarible> tlisValores)
        {
            //Creo un diccionario de valores e invoco al método convencional
            Dictionary<string, string> dicValores = new Dictionary<string, string>();

            tlisValores.ToList().ForEach(variable => dicValores.Add(variable._Clave, variable._Valor));

            _EstablecerVariables(dicValores);
        }

        private void Init()
        {
            //Limpio lo que pudiera tener
            claseInicializada = false;
            contadorAutomatico = 1;
            dicValoresPorDefecto.Clear();
            lisNombresVariablesFraInicializados.Clear();

            //Ha de obtener el número de asientos y por asiento determinar si hay variables de factura y si estas variables admiten valores automàticos
            bool tengoVariablesFactura = _ObtenerNombresDeVariablesColumnaRelacion().Count() > 0;
            if (tengoVariablesFactura)
            {
                inicilizarValoresFactura(); //Llamo 
            }

            claseInicializada = true;
        }

        private void inicilizarValoresFactura()
        {
            //Recupero la cantidad de asientos a generar 
            var numerosDeAsientos = generadorDePredefinidos._LineasAsientoPredefinido.Select(linea => linea._Asiento).Distinct().ToList();

            //Ordeno lo que me llega
            var lineasOrdenadas = generadorDePredefinidos._LineasAsientoPredefinido.OrderBy(loEle => loEle._Asiento).ThenBy(loEle => loEle._Orden).ToList();

            foreach (var numeroDeAsiento in numerosDeAsientos) //Voy iterando por los asientos a generar
            {
                var lineasDelAsiento = lineasOrdenadas.Where(lolinea => lolinea._Asiento == numeroDeAsiento).ToList();
                inicializarValoresFacturaPorAsientoDeLasLineas(lineasDelAsiento);
            }
            lisNombresVariablesFraInicializados = _ObtenerNombresDeVariablesColumnaRelacion().ToList();
        }

        private void inicializarValoresFacturaPorAsientoDeLasLineas(List<AsientoPredefinido.LineaAsientoPredefinido> lineasDelAsiento)
        {
            if (lineasDelAsiento.Any() && contieneVariablesDeFactura(lineasDelAsiento)) //Si el asiento tiene lineas y variables de factura en esas lineas
            {
                var nombresVariablesDeFactura = obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloPropiedadRelacion, lineasDelAsiento).ToList();
                if (nombresVariablesDeFactura.Count() == 1) //Si solo tengo una...
                {
                    string nombre = nombresVariablesDeFactura.First();
                    bool necesitaFactura = generadorDePredefinidos._DebeContenerInformacionDeFactura(lineasDelAsiento);
                    if (necesitaFactura)
                    {
                        bool esDeCompras = generadorDePredefinidos._ModoCompras(lineasDelAsiento);
                        if (esDeCompras) //Para compras se requiere el flag
                        {
                            if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_factucom")))
                            {
                                insertarValorDefectoFactura(nombre, obtenerLiteralNumeradoFra());
                            }
                            else //Sino hay contador, no puedo dar número
                                insertarValorDefectoFactura(nombre, "");

                        }
                        else //Ventas... automático
                        {
                            insertarValorDefectoFactura(nombre, obtenerLiteralNumeradoFra());
                        }
                    }
                    else
                        insertarValorDefectoFacturaSiFalta(nombre, ""); //No es una factura => Que lo inserte blanco sino lo tiene, si ya lo ha insertado previamente que respete el valor
                }
                else //Hay varias... no tengo ni idea de como procesarlas, asigno valor blanco sino lo tengo definido ya
                {
                    nombresVariablesDeFactura.ForEach(nombre => insertarValorDefectoFacturaSiFalta(nombre, "")); //Inserto como blancos los que no tengo
                }
            }
        }

        private bool todasLasFacturasConValorDefecto()
        {
            var variablesFacturaActual = _ObtenerNombresDeVariablesColumnaRelacion().ToList();
            return (variablesFacturaActual.All(loVar => lisNombresVariablesFraInicializados.Contains(loVar)));
        }

        private string obtenerLiteralNumeradoFra()
        {
            string literal = "<<NúmeroAutomático" + contadorAutomatico + ">>";
            contadorAutomatico += 1;
            return literal;
        }

        private void insertarValorDefectoFacturaSiFalta(string tcClave, string tcValor)
        {
            if (!dicValoresPorDefecto.ContainsKey(tcClave))
                dicValoresPorDefecto.Add(tcClave, tcValor);
        }

        private void insertarValorDefectoFactura(string tcClave, string tcValor)
        {
            if (dicValoresPorDefecto.ContainsKey(tcClave))
            {
                if (String.IsNullOrWhiteSpace(dicValoresPorDefecto[tcClave])) //Sólo actualizo si el valor es blanco
                    dicValoresPorDefecto[tcClave] = tcValor;
            }
            else
                dicValoresPorDefecto.Add(tcClave, tcValor);
        }

        private bool contieneVariablesDeFactura(IEnumerable<AsientoPredefinido.LineaAsientoPredefinido> source)
        {
            return obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloPropiedadRelacion, source).Count() > 0;
        }

        public string ObtenerValorPorDefectoDe(string tcNombreVariable)
        {
            if (String.IsNullOrWhiteSpace(tcNombreVariable))
                return "";

            if (!claseInicializada) //Sino esta inicializada
                Init();
            else
            {
                if (!todasLasFacturasConValorDefecto()) //Esta inicializada pero han cambiado valores => inicializo sin restear
                    inicilizarValoresFactura();
            }

            tcNombreVariable = tcNombreVariable.TrimEnd();

            //Si tengo el valor en el diccionario lo devuelvo sino blanco
            if (dicValoresPorDefecto.ContainsKey(tcNombreVariable))
                return dicValoresPorDefecto[tcNombreVariable];
            else
                return "";
        }

        #endregion Métodos públicos

        private int contadorAutomatico = 1;
        private Dictionary<string, string> dicValoresPorDefecto = new Dictionary<string, string>();
        private bool claseInicializada = false;
        private List<string> lisNombresVariablesFraInicializados = new List<string>();

        private enum TipoFiltroVariables
        {
            Todas = 0,
            SoloCuentas = 1,
            SoloVariables = 2,
            SoloPropiedadCuenta = 3,
            SoloPropiedadCtaAsignacion = 4,
            SoloPropiedadRelacion = 5,
            SoloDebeHaber = 6,
            //SoloPropiedadContrapar = 7,
        }

        private IEnumerable<string> obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables teTipoFiltrado, IEnumerable<AsientoPredefinido.LineaAsientoPredefinido> source = null)
        {
            //Lista de retorno
            List<string> llisVariables = new List<string>();
            List<string> llisVariablesTemp = new List<string>();

            //Sino me han pasado un subconjunto de líneas, evaluo todas
            if (source == null)
                source = generadorDePredefinidos._LineasAsientoPredefinido;

            foreach (var lineaAsientoPredef in source)
            {
                switch (teTipoFiltrado)
                {

                    case TipoFiltroVariables.SoloCuentas:
                        llisVariablesTemp = lineaAsientoPredef._ObtenerVariablesPropiedadesDeTipoCuenta();
                        break;


                    case TipoFiltroVariables.SoloVariables:
                        llisVariablesTemp = lineaAsientoPredef._ObtenerVariablesPropiedadesExceptoDeTipoCuenta();
                        break;


                    case TipoFiltroVariables.SoloPropiedadCuenta:
                        llisVariablesTemp = lineaAsientoPredef._ObtenerVariablesPropiedadCuenta();
                        break;


                    case TipoFiltroVariables.SoloPropiedadCtaAsignacion:
                        llisVariablesTemp = lineaAsientoPredef._ObtenerVariablesPropiedadCtaAsig();
                        break;

                    case TipoFiltroVariables.SoloPropiedadRelacion:
                        llisVariablesTemp = lineaAsientoPredef._ObtenerVariablesPropiedadRelacion();
                        break;

                    case TipoFiltroVariables.SoloDebeHaber:
                        llisVariablesTemp = lineaAsientoPredef._ObtenerVariablesPropiedadesDebeHaber();
                        break;

                    case TipoFiltroVariables.Todas:
                    default:
                        llisVariablesTemp = lineaAsientoPredef._ObtenerVariables();
                        break;
                }

                llisVariables.AddRange(llisVariablesTemp);
            }

            return llisVariables.Distinct().ToList().OrderBy(loEle => loEle);
        }

        private IEnumerable<IAsientoPredefinidoVarible> obtenerVariablesFiltradasPor(TipoFiltroVariables teTipoFiltrado, IEnumerable<AsientoPredefinido.LineaAsientoPredefinido> source = null)
        {
            List<IAsientoPredefinidoVarible> listaVariables = new List<IAsientoPredefinidoVarible>();

            //Sino me han pasado un subconjunto de líneas, evaluo todas
            if (source == null)
                source = generadorDePredefinidos._LineasAsientoPredefinido;

            //Primero debo obtener la lista de nombres de variables
            var nombresDeVariables = obtenerNombresDeVariableFiltradasPor(teTipoFiltrado, source);
            if (nombresDeVariables.Any())
            {
                //Una vez tengo los nombres debo determinar si hay alguna que requiera lógica especial de asignación (facturas básicamente)
                var nombresDeVariablesDeFactura = obtenerNombresDeVariableFiltradasPor(TipoFiltroVariables.SoloPropiedadRelacion, source);
                if (nombresDeVariablesDeFactura.Any()) //Si hay alguna de tipo factura
                {
                    //Busco las coincidentes
                    var variablesCoincidentes = nombresDeVariables.Intersect(nombresDeVariablesDeFactura).ToList();
                    if (variablesCoincidentes.Any())
                    {
                        variablesCoincidentes.ForEach(nombreDeVariable => listaVariables.Add(generarVariable(nombreDeVariable, source)));
                        nombresDeVariables = nombresDeVariables.Except(variablesCoincidentes).ToList(); //Suprimo las que ya he instanciado
                    }
                }

                //Instancio el negocio para las variables normales
                foreach (var nombreDeVariable in nombresDeVariables)
                {
                    listaVariables.Add(new VariableDeSusticionEnAsientoPredefinido(nombreDeVariable));
                }
            }

            return listaVariables;
        }

        private IAsientoPredefinidoVarible generarVariable(string tcNombreVariable, IEnumerable<AsientoPredefinido.LineaAsientoPredefinido> source)
        {
            IAsientoPredefinidoVarible nuevaVariable = null;

            string varible = "[" + tcNombreVariable + "]"; //Reconstruyo el formato de variable para poder buscarla

            var lineasConLaVariable = source.Where(loLinea => loLinea._Relacion.Contains(varible)).ToList();
            var numerosDeAsiento = lineasConLaVariable.Select(lolinea => lolinea._Asiento).ToList();
            foreach (var numAsiento in numerosDeAsiento)
            {
                var lineasDelAsiento = source.Where(lolinea => lolinea._Asiento == numAsiento).ToList();
                if (generadorDePredefinidos._EsFacturaCompra(lineasDelAsiento) || 
                    generadorDePredefinidos._EsFacturaNominas(lineasDelAsiento) ||
                    lineasDelAsiento.Any(l => l._IvaNoSujeto && CONTABILIDAD._EsProveedor(l._Cuenta)))
                {
                    nuevaVariable = new VariableDeFacturaCompraEnAsientoPredefinido(tcNombreVariable, ObtenerValorPorDefectoDe(tcNombreVariable));
                    break;
                }
                else
                {
                    if(generadorDePredefinidos._EsFacturaVenta(lineasDelAsiento) ||
                       lineasDelAsiento.Any(l => l._IvaNoSujeto && CONTABILIDAD._EsCliente(l._Cuenta)))
                    {
                        
                        //Bug 171444 => Propagar serie de factura
                        var serieFactura = (_trabajaConSeriesDeFactura ? generadorDePredefinidos._SerieFactura : "");
                        nuevaVariable = new VariableDeFacturaVentaEnAsientoPredefinido(tcNombreVariable, ObtenerValorPorDefectoDe(tcNombreVariable), serieFactura);
                        break;
                    }
                }
            }

            if(nuevaVariable == null)
            {
                //No debería... 
                Trace.WriteLineIf(Debugger.IsAttached, "Tipo de variable de factura no inicializado.");
                nuevaVariable = new VariableDeSusticionEnAsientoPredefinido(tcNombreVariable); //Variable corriente y moliente
            }

            return nuevaVariable;
        }

    }
}