using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace OliviaAddInPro.Model
{

    /**
    *	@file RecogidaDef.cs
    *	Clase con definiciones de recogida comunes al proyecto Olivia y a OliviaTask.
    */
    /**
    *	Clase con definiciones de recogida comunes al proyecto Olivia y a OliviaTask.
    */

    class RecogidaDef
    {
        //*************************************************************************************
        //Enums y structs generales   
        /**
        * Nombre de los campos (de las capas) sobre los que se realizarán consultas para la recogida
        */
        public struct Campos
        {
            public string cons_id;          //<Campo a consultar de la capa de contenedores para leer el id
            public string cons_nomrec;      //<Campo a consultar de la capa de contenedores para leer el nombre del tipo de recogida
            public string cons_lateral;     //<Campo a consultar de la lateralidad del tipo de recogida
            public string cons_fracc;       //<Campo a consultar de la capa de contenedores para leer la fracción
            public string cons_capac;       //<Campo a consultar de la capa de contenedores para leer la capacidad
            public string cons_uds;         //<Campo a consultar de la capa de contenedores para leer las unidades
            public string cons_kgrec;       //<Campo a consultar de la capa de contenedores para leer los kg de la recogida            
        }
        /**
        * Nombre de los parámetros que intervienen en el cálculo para la recogida
        */
        public struct Parametros
        {
            public static int t_vaciM;          //<Tiempo de vaciado máximo admitido
            public static int t_vacim;          //<Tiempo de vaciado mínimo admitido
            public static int t_llegsalM;       //<Tiempo de llegada y salida a las instalaciones máximo admitido
            public static int t_llegsalm;       //<Tiempo de llegada y salida a las instalaciones mínimo admitido
            public static int t_llegsal;        //<Tiempo de llegada y salida establecido
            public static int t_descM;          //<Tiempo de descarga máximo admitido
            public static int t_descm;          //<Tiempo de descarga mínimo admitido
            public static int t_desc;           //<Tiempo de descarga establecido
            public static int t_convM;          //<Tiempo de convenio máximo admitido
            public static int t_convm;          //<Tiempo de convenio mínimo admitido
            public static int t_conv;           //<Tiempo de convenio establecido
            public static int t_descansoM;      //<Tiempo de descanso máximo admitido
            public static int t_descansom;      //<Tiempo de descanso mínimo admitido
            public static int t_descanso;       //<Tiempo de descanso establecido
            public static int h_inicio;         //<Hora de inicio de la jornada de trabajo
            public static int dens_vehi_org;    //<Densidades en camión para fraccion orgánica
            public static int dens_vehi_res;    //<Densidades en camión para fraccion resto
            public static int dens_vehi_env;    //<Densidades en camión para fraccion envases
            public static int dens_vehi_pap;    //<Densidades en camión para fraccion Papel y Cartón
            public static int dens_vehi_vid;    //<Densidades en camión para fraccion vidrio
            public static int dens_vehi_otr;    //<Densidades en camión para fraccion otra
            public static int dens_cont_org;    //<Densidades en contenedor para fraccion orgánica
            public static int dens_cont_res;    //<Densidades en contenedor para fraccion resto
            public static int dens_cont_env;    //<Densidades en contenedor para fraccion envases
            public static int dens_cont_pap;    //<Densidades en contenedor para fraccion Papel y Cartón
            public static int dens_cont_vid;    //<Densidades en contenedor para fraccion vidrio
            public static int dens_cont_otr;    //<Densidades en contenedor para fraccion otra
            public static double anch_vehi_3;   //<Ancho del vehículo de 3 ejes
            public static double anch_vehi_2;   //<Ancho del vehículo de 2 ejes
            public static double anch_vehi_s;   //<Ancho del vehículo Satélite
            public static double rad_giro_3;    //<Radio de giro del vehículo de 3 ejes
            public static double rad_giro_2;    //<Radio de giro del vehículo de 2 ejes
            public static double rad_giro_s;    //<Radio de giro del vehículo Satélite
            public static int t_vaci_tra;       //<Tiempo de vaciado para cargas trasera
            public static int t_vaci_lat;       //<Tiempo de vaciado para cargas lateral
            public static int t_vaci_sup;       //<Tiempo de vaciado para cargas superior
            public static int t_vaci_bi;        //<Tiempo de vaciado para cargas bilateral
            public static int t_vaci_bol;       //<Tiempo de vaciado para cargas bolseo
            public static int t_vaci_lav;       //<Tiempo de vaciado para cargas lavado
            public static int t_vaci_otr;       //<Tiempo de vaciado para cargas otra
            public static int kgmaxM;           //<Kg máximo que puede llevar un vehículo
            public static int kgmaxm;           //<Kg mínimo que puede llevar un vehículo
            public static int carga_maxM;       //<Carga máxima para recoger los contenedores
            public static int carga_maxm;       //<Carga mínima para recoger los contenedores
        };
        /**
         * Fracciones.
         * Tipos de residuos a recoger
         */ 
        public enum TiposFracción
        {
            Organica,         //<Fracción Orgánica
            Resto,            //<Fracción de Restos 
            Envases,          //<Fracción de Envases
            Papel,            //<Fracción de Papel y Cartón
            Vidrio,           //<Fracción de Vidrio
            Otra,             //<Fracción genérica para otro tipo de residuos
            N
        }
        /**
         * Tipo de carga del vehículo
         */ 
        public enum TiposCarga
        {
            Trasera,            //<Carga trasera
            Lateral,            //<Carga lateral
            Superior,           //<Carga superior
            Bilateral,          //<Carga bilaterar
            BolseoPtaPta,       //<Bolseo / Puerta a Puerta
            Lavado,             //<Lavado de contenedores
            Otra,               //<Carga genérica para otro tipo de cargas
            N           
        }
        /**
         * Tipo de vehículo
         */
        public enum TiposVehic
        {
            Ejes3,              //<Vehículo de 3 ejes
            Ejes2,              //<Vehículo de 2 ejes
            Satelite,           //<Vehículo satélite
            N
        }
        /**
        * Tipo de lateralidad de carga de los vehículos
        */
        public enum Lateralidad
        {
            Ambos,              //<Carga por ambos lados del camión
            Dcha,               //<Carga por lado derecho del camión
            Izqda,              //<Carga por lado izquierdo del camión
            N
        }
        public struct CargaMax
        {
            public int n;           //<Número de opciones de vehículos de ese tipo con esa carga
            public int i_def;       //<La opción por defecto de entre las posibles
            public int[] vol;       //<Array de opciones, su volumen en m3
            public int[,] offset;   //<Array de valores de correccion de los kg máximos de carga

        }
        //*************************************************************************************
        //Variables
        /** 
        * Array de cadenas de caracteres enumerando los tipos de fracción
        */
        public static String[] tipos_fracc_str = new String[(int)RecogidaDef.TiposFracción.N - 1];
        /** 
        * Array de cadenas de caracteres enumerando los tipos de carga
        */
        public static String[] tipos_carg_str = new String[(int)RecogidaDef.TiposCarga.N - 1];
        /** 
        * Array de strings con los prefijos de la fracción para la importación de capas a la GDB
        */
        public static String[] preffracc_gdb = new String[(int)RecogidaDef.TiposFracción.N];
        /** 
        * Array de strings con los prefijos de las cargas para la importación de capas a la GDB
        */
        public static String[] prefcarg_gdb = new String[(int)RecogidaDef.TiposCarga.N];
        /** 
        * Array de strings con nombres de los sibmolos referentes al tipo de recogida de basuras
        */
        public static String[] nombre_simbrec_vsm = new String[20];
        /** 
        * Array de strings con los tipos de recogida de basuras
        */
        public static String[] simb_rec_vsm = new String[9];
        /** 
        * Array de strings con los tipos de basuras
        */
        public static String[] simb_tipbasura = new String[5];
        /**
         * Densidades de residuos en el camión, una vez compactados, en función de la fracción, en kg/m3
         */ 
        public static int[] dens_frac_cami = new int[(int)RecogidaDef.TiposFracción.N];
        /**
         * Densidades de residuos en el contenedor, en función de la fracción, en kg/m3
         */
        public static int[] dens_frac_cont = new int[(int)RecogidaDef.TiposFracción.N];
        /**
         * Anchura de los vehículos en función del tipo
         */
        public static double[] ancho_vehic = new double[(int)RecogidaDef.TiposVehic.N];
        /**
        * Ángulo de giro de los vehículos en función del tipo en grados
        */
        public static double[] giro_vehic = new double[(int)RecogidaDef.TiposVehic.N];
        /**
         * Tiempo de vaciado de los contenedores en función del tipo de carga, en segundos
         */
        public static int[] t_vaci = new int[(int)RecogidaDef.TiposCarga.N];
        /** 
        * Array de cadenas de caracteres enumerando los tipos de lateralidad de carga
        */
        public static String[] tipos_lateralidad = new String[(int)RecogidaDef.Lateralidad.N];
        /**
         * Kg de recogida del contenedor
         */
        public static int kgrec_cont=200;
        /*
        * indica si se ha marcado la opción de campo de kg recogida, si no es un valor fijo
        */
        public static bool kgrec_camp = false; 
        /*
        * indica si se ha marcado la opción de recoger sólo los contenedores llenos en el diálogo de las propiedades de los campos de recogida
        */
        public static bool lleno = false;  
        /**
         * Nombres de los campos
         */
        public static Campos campos;
        /**
         * Nombres por defecto de los campos
         */
        public static Campos campos_def;
        /*
         * array de las diferentes consltas de atributos a realizar en la capa de recogida.
         */
        public static string[] filtro_str = null;
        /** 
         * Array de cadenas de caracteres enumerando los tipos de vehículos
         */
        public static String[] tipos_vehic_str = new String[(int)RecogidaDef.TiposVehic.N];
        /** 
         * Array de cadenas de doubles enumerando los kg máximos permitidos por cada tipo de vehículo
         */
        public static CargaMax[,] cargas_max_vehic = new CargaMax[(int)RecogidaDef.TiposCarga.N, (int)RecogidaDef.TiposVehic.N];
        //************************************************************************
        public static void iniciaRecoDef()
        {
            //Nombre de simbolos VSM
            rellena_simbrec_vsm(); 
            rellena_matrs();
            rellena_preffracc_gdb();
            rellena_prefcarg_gdb();
            rellena_simbol_rec();
            rellena_simb_tipbasura();

        }
        /**
        * Inicializa la matriz de strings con los nombres de los sibmolos referentes al tipo de recogida de basuras
        */
        private static void rellena_simbrec_vsm()
        {
            RecogidaDef.nombre_simbrec_vsm[0] = "Autocompactador";
            RecogidaDef.nombre_simbrec_vsm[1] = "Bilateral";
            RecogidaDef.nombre_simbrec_vsm[2] = "Bolseo";
            RecogidaDef.nombre_simbrec_vsm[3] = "Caja_Abierta";
            RecogidaDef.nombre_simbrec_vsm[4] = "Neumatica";
            RecogidaDef.nombre_simbrec_vsm[5] = "Pilas";
            RecogidaDef.nombre_simbrec_vsm[6] = "CL Envases";
            RecogidaDef.nombre_simbrec_vsm[7] = "Cl Papel";
            RecogidaDef.nombre_simbrec_vsm[8] = "CL Vidrio";
            RecogidaDef.nombre_simbrec_vsm[9] = "CL Organica";
            RecogidaDef.nombre_simbrec_vsm[10] = "CL Resto";
            RecogidaDef.nombre_simbrec_vsm[11] = "CT Envases";
            RecogidaDef.nombre_simbrec_vsm[12] = "CT Papel";
            RecogidaDef.nombre_simbrec_vsm[13] = "CT Vidrio";
            RecogidaDef.nombre_simbrec_vsm[14] = "CT Organica";
            RecogidaDef.nombre_simbrec_vsm[15] = "CT Resto";
            RecogidaDef.nombre_simbrec_vsm[16] = "Iglu Envases";
            RecogidaDef.nombre_simbrec_vsm[17] = "Iglu Papel";
            RecogidaDef.nombre_simbrec_vsm[18] = "Iglu Vidrio";
            RecogidaDef.nombre_simbrec_vsm[19] = "Soterrados";
        }
        /**
        * Inicializa la matriz de strings con los prefijos (fracción) que llevarán los featureclass de la geodatabase importada a ArcGIS una vez realizada la planificación
        */
        private static void rellena_preffracc_gdb()
        {
            RecogidaDef.preffracc_gdb[(int)RecogidaDef.TiposFracción.Organica] = "Org";
            RecogidaDef.preffracc_gdb[(int)RecogidaDef.TiposFracción.Resto] = "R";
            RecogidaDef.preffracc_gdb[(int)RecogidaDef.TiposFracción.Envases] = "E";
            RecogidaDef.preffracc_gdb[(int)RecogidaDef.TiposFracción.Papel] = "P";
            RecogidaDef.preffracc_gdb[(int)RecogidaDef.TiposFracción.Vidrio] = "V";
            RecogidaDef.preffracc_gdb[(int)RecogidaDef.TiposFracción.Otra] = "Otr_";
        }

        /**
        * Inicializa la matriz de strings con los prefijos (fracción) que llevarán los featureclass de la geodatabase importada a ArcGIS una vez realizada la planificación
        */
        private static void rellena_prefcarg_gdb()
        {
            RecogidaDef.prefcarg_gdb[(int)RecogidaDef.TiposFracción.Organica] = "Tra";
            RecogidaDef.prefcarg_gdb[(int)RecogidaDef.TiposFracción.Resto] = "Lat";
            RecogidaDef.prefcarg_gdb[(int)RecogidaDef.TiposFracción.Envases] = "BiLat";
            RecogidaDef.prefcarg_gdb[(int)RecogidaDef.TiposFracción.Papel] = "Bols";
            RecogidaDef.prefcarg_gdb[(int)RecogidaDef.TiposFracción.Vidrio] = "Lav";
            RecogidaDef.prefcarg_gdb[(int)RecogidaDef.TiposFracción.Otra] = "Otr_";
        }

        /**
        * Inicializa la matriz de strings con los tipos de recogida
        */
        private static void rellena_simbol_rec()
        {
            RecogidaDef.simb_rec_vsm[0] = RecogidaDef.nombre_simbrec_vsm[0];
            RecogidaDef.simb_rec_vsm[1] = RecogidaDef.nombre_simbrec_vsm[1];
            RecogidaDef.simb_rec_vsm[2] = RecogidaDef.nombre_simbrec_vsm[2];
            RecogidaDef.simb_rec_vsm[3] = RecogidaDef.nombre_simbrec_vsm[3];
            RecogidaDef.simb_rec_vsm[4] = RecogidaDef.nombre_simbrec_vsm[4];
            RecogidaDef.simb_rec_vsm[5] = RecogidaDef.nombre_simbrec_vsm[5];
            RecogidaDef.simb_rec_vsm[6] = RecogidaDef.tipos_carg_str[(int)RecogidaDef.TiposCarga.Lateral];
            RecogidaDef.simb_rec_vsm[7] = RecogidaDef.tipos_carg_str[(int)RecogidaDef.TiposCarga.Trasera];
            RecogidaDef.simb_rec_vsm[8] = RecogidaDef.tipos_carg_str[(int)RecogidaDef.TiposCarga.Superior];
        }

        /**
        * Inicializa la matriz de strings con los tipos de recogida
        */
        private static void rellena_simb_tipbasura()
        {
            RecogidaDef.simb_tipbasura[0] = RecogidaDef.tipos_fracc_str[(int)RecogidaDef.TiposFracción.Envases];
            RecogidaDef.simb_tipbasura[1] = RecogidaDef.tipos_fracc_str[(int)RecogidaDef.TiposFracción.Papel];
            RecogidaDef.simb_tipbasura[2] = RecogidaDef.tipos_fracc_str[(int)RecogidaDef.TiposFracción.Vidrio];
            RecogidaDef.simb_tipbasura[3] = RecogidaDef.tipos_fracc_str[(int)RecogidaDef.TiposFracción.Organica];
            RecogidaDef.simb_tipbasura[4] = RecogidaDef.tipos_fracc_str[(int)RecogidaDef.TiposFracción.Resto];
        }
        /**
         * Rellena las matrices de datos
         */
        private static void rellena_matrs()
        {
            //Rellena los tipos de vehículo
            RecogidaDef.tipos_vehic_str[(int)RecogidaDef.TiposVehic.Ejes3] = "3 Ejes";
            RecogidaDef.tipos_vehic_str[(int)RecogidaDef.TiposVehic.Ejes2] = "2 Ejes";
            RecogidaDef.tipos_vehic_str[(int)RecogidaDef.TiposVehic.Satelite] = "Satélite";

            //Rellena las densidades en camión
            RecogidaDef.dens_frac_cami[(int)RecogidaDef.TiposFracción.Organica] = RecogidaDef.Parametros.dens_vehi_org;
            RecogidaDef.dens_frac_cami[(int)RecogidaDef.TiposFracción.Resto] = RecogidaDef.Parametros.dens_vehi_res;
            RecogidaDef.dens_frac_cami[(int)RecogidaDef.TiposFracción.Envases] = RecogidaDef.Parametros.dens_vehi_env;
            RecogidaDef.dens_frac_cami[(int)RecogidaDef.TiposFracción.Papel] = RecogidaDef.Parametros.dens_vehi_pap;
            RecogidaDef.dens_frac_cami[(int)RecogidaDef.TiposFracción.Vidrio] = RecogidaDef.Parametros.dens_vehi_vid;
            RecogidaDef.dens_frac_cami[(int)RecogidaDef.TiposFracción.Otra] = RecogidaDef.Parametros.dens_vehi_otr;

            //Rellena las densidades en contenedor
            RecogidaDef.dens_frac_cont[(int)RecogidaDef.TiposFracción.Organica] = RecogidaDef.Parametros.dens_cont_org;
            RecogidaDef.dens_frac_cont[(int)RecogidaDef.TiposFracción.Resto] = RecogidaDef.Parametros.dens_cont_res;
            RecogidaDef.dens_frac_cont[(int)RecogidaDef.TiposFracción.Envases] = RecogidaDef.Parametros.dens_cont_env;
            RecogidaDef.dens_frac_cont[(int)RecogidaDef.TiposFracción.Papel] = RecogidaDef.Parametros.dens_cont_pap;
            RecogidaDef.dens_frac_cont[(int)RecogidaDef.TiposFracción.Vidrio] = RecogidaDef.Parametros.dens_cont_vid;
            RecogidaDef.dens_frac_cont[(int)RecogidaDef.TiposFracción.Otra] = RecogidaDef.Parametros.dens_cont_otr;

            //Rellena las anchuras de los vehículos
            RecogidaDef.ancho_vehic[(int)RecogidaDef.TiposVehic.Ejes3] = RecogidaDef.Parametros.anch_vehi_3;
            RecogidaDef.ancho_vehic[(int)RecogidaDef.TiposVehic.Ejes2] = RecogidaDef.Parametros.anch_vehi_2;
            RecogidaDef.ancho_vehic[(int)RecogidaDef.TiposVehic.Satelite] = RecogidaDef.Parametros.anch_vehi_s;

            //Rellena los ángulos de giro de los vehículos
            RecogidaDef.giro_vehic[(int)RecogidaDef.TiposVehic.Ejes3] = RecogidaDef.Parametros.rad_giro_3;
            RecogidaDef.giro_vehic[(int)RecogidaDef.TiposVehic.Ejes2] = RecogidaDef.Parametros.rad_giro_2;
            RecogidaDef.giro_vehic[(int)RecogidaDef.TiposVehic.Satelite] = RecogidaDef.Parametros.rad_giro_s;

            //Rellena los tiempos de vaciado
            RecogidaDef.t_vaci[(int)RecogidaDef.TiposCarga.Trasera] = RecogidaDef.Parametros.t_vaci_tra;
            RecogidaDef.t_vaci[(int)RecogidaDef.TiposCarga.Lateral] = RecogidaDef.Parametros.t_vaci_lat;
            RecogidaDef.t_vaci[(int)RecogidaDef.TiposCarga.Superior] = RecogidaDef.Parametros.t_vaci_sup;
            RecogidaDef.t_vaci[(int)RecogidaDef.TiposCarga.Bilateral] = RecogidaDef.Parametros.t_vaci_bi;
            RecogidaDef.t_vaci[(int)RecogidaDef.TiposCarga.BolseoPtaPta] = RecogidaDef.Parametros.t_vaci_bol;
            RecogidaDef.t_vaci[(int)RecogidaDef.TiposCarga.Lavado] = RecogidaDef.Parametros.t_vaci_lav;
            RecogidaDef.t_vaci[(int)RecogidaDef.TiposCarga.Otra] = RecogidaDef.Parametros.t_vaci_otr;


            //Rellena las matrices de carga máxima por tipo de vehículo y tipo de carga
            rellena_matrs_carg();
        }

        /**
         * Función general para rellenar campos de la matriz de cargas máximas por tipo de carga y de vehículo
         */
        private static void rellena_carg(int icar, int iveh, int n, int i_def, int[] info)
        {
            cargas_max_vehic[icar, iveh].n = n;
            cargas_max_vehic[icar, iveh].i_def = i_def;
            cargas_max_vehic[icar, iveh].vol = null;
            cargas_max_vehic[icar, iveh].offset = null;
            if (n <= 0)
                return;
            cargas_max_vehic[icar, iveh].vol = new int[n];
            for (int i = 0; i < n; i++)
            {
                cargas_max_vehic[icar, iveh].vol[i] = info[i];
            }

        }

        /**
         * Función general para rellenar campos de la matriz de cargas máximas por tipo de carga y de vehículo
         */
        private static void rellena_carg_offset(int icar, int iveh, int ifrac, int n, int[] info)
        {
            if (cargas_max_vehic[icar, iveh].offset == null)
                cargas_max_vehic[icar, iveh].offset = new int[n, (int)RecogidaDef.TiposFracción.N];
            for (int i = 0; i < n; i++)
            {
                cargas_max_vehic[icar, iveh].offset[i, ifrac] = info[i];
            }
        }
        /**
         * Rellena la matriz de las opciones de vehículos que hay de cada tipo de carga
         * y dimensión
         */
        private static void rellena_matrs_carg()
        {
            int[] info = new int[10];
            int n, i_def, icar, iveh;

            //Rellena las opciones de carga máxima por vehículo
            //Trasera-satelite
            n = 4;
            i_def = 2;
            info[0] = 2;
            info[1] = 3;
            info[2] = 5;
            info[3] = 7;
            rellena_carg((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Satelite, n, i_def, info);
            //rellena la corrección de la carga máxima
            info[0] = info[1] = -500;
            info[2] = info[3] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Resto, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Organica, n, info);

            //Trasera-2 ejes
            n = 6;
            i_def = 2;
            info[0] = 8;
            info[1] = 10;
            info[2] = 12;
            info[3] = 14;
            info[4] = 16;
            info[5] = 17;
            rellena_carg((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes2, n, i_def, info);
            //rellena la corrección de la carga máxima
            info[1] = -500;
            info[2] = -1000;
            info[3] = -1500;
            info[4] = -2000;
            info[0] = info[5] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Resto, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Organica, n, info);

            //Trasera-3ejes
            n = 4;
            i_def = 3;
            info[0] = 18;
            info[1] = 20;
            info[2] = 22;
            info[3] = 23;
            rellena_carg((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes3, n, i_def, info);

            //Lateral-satelite, no hay
            rellena_carg((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Satelite, 0, 0, null);

            //Lateral - 2 ejes
            n = 2;
            i_def = 1;
            info[0] = 15;
            info[1] = 17;
            rellena_carg((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes2, n, i_def, info);
            //rellena la corrección de la carga máxima
            info[0] = -500;
            info[1] = -1000;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Resto, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Organica, n, info);

            //Lateral - 3 ejes
            n = 3;
            i_def = 2;
            info[0] = 21;
            info[1] = 23;
            info[2] = 26;
            rellena_carg((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes3, n, i_def, info);

            //Superior - satelite, no hay
            rellena_carg((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Satelite, 0, 0, null);

            //Superior - 2 ejes
            n = 2;
            i_def = 0;
            info[0] = 16;
            info[1] = 17;
            rellena_carg((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes2, n, i_def, info);

            //Superior - 3 ejes
            n = 3;
            i_def = 2;
            info[0] = 20;
            info[1] = 23;
            info[2] = 25;
            rellena_carg((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes3, n, i_def, info);

            //Bilateral - satelite, no hay
            rellena_carg((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Satelite, 0, 0, null);

            //Bilateral - 2 ejes
            n = 3;
            i_def = 1;
            info[0] = 14;
            info[1] = 16;
            info[2] = 18;
            rellena_carg((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes2, n, i_def, info);

            //Bilateral - 3 ejes
            n = 3;
            i_def = 1;
            info[0] = 20;
            info[1] = 23;
            info[2] = 26;
            rellena_carg((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes3, n, i_def, info);

            //Bolseo - todas, no hay
            //Lavado - todas, no hay
            //Otra - todas, no hay
            for (icar = (int)RecogidaDef.TiposCarga.BolseoPtaPta; icar < (int)RecogidaDef.TiposCarga.N; icar++)
            {
                for (iveh = (int)RecogidaDef.TiposVehic.Ejes3; iveh < (int)RecogidaDef.TiposVehic.N; iveh++)
                {
                    rellena_carg(icar, iveh, 0, 0, null);
                }
            }

            ////////////////////////////////////////////////////////
            //Barcelona new
            rellena_offsets_bcn();
        }

        private static void rellena_offsets_bcn()
        {
            int[] info = new int[10];
            int n, i_def;
            ////////////////////////////////////////////////////////
            //Barcelona new

            //Bilateral - satelite
            n = 1;
            i_def = 0;
            info[0] = 11;
            rellena_carg((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Satelite, n, i_def, info);

            //offsets
            //Bilateral - satelite - resto, org
            info[0] = -3700;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Resto, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Organica, n, info);

            //bilateral -satélite - envases
            info[0] = 480;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //bilateral -satélite - papel
            info[0] = -2160;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Papel, n, info);

            //bilateral -satélite - vidrio
            info[0] = -2050;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Trasera - satélite - organico, resto
            n = 4;
            info[0] = -500;
            info[1] = -500;
            info[2] = 0;
            info[3] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Trasera - satélite - envases
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            info[3] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Trasera - satélite - papel
            info[0] = -220;
            info[1] = -330;
            info[2] = -550;
            info[3] = -770;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Papel, n, info);

            //Trasera - satélite - vidrio
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            info[3] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Satelite, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Trasera - 2 ejes - resto, org
            n = 6;
            info[0] = 0;
            info[1] = -500;
            info[2] = -1000;
            info[3] = -1500;
            info[4] = -2000;
            info[5] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
               (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Trasera - 2 ejes - envases
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            info[3] = 0;
            info[4] = 0;
            info[5] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Trasera - 2 ejes - papel
            info[0] = -880;
            info[1] = -1100;
            info[2] = -1320;
            info[3] = -1540;
            info[4] = -1760;
            info[5] = -1870;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Papel, n, info);

            //Trasera - 2 ejes - vidrio
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            info[3] = 0;
            info[4] = 0;
            info[5] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Trasera - 3 ejes - resto, org
            n = 4;
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            info[3] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
               (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Trasera - 3 ejes - envases
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Trasera - 3 ejes - papel
            info[0] = -1980;
            info[1] = -2200;
            info[2] = -2420;
            info[3] = -2530;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Papel, n, info);

            //Trasera - 3 ejes - vidrio
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            info[3] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Trasera,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Lateral - 2 ejes - resto, org
            n = 2;
            info[0] = -500;
            info[1] = -1000;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
               (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Lateral - 2 ejes - envases
            n = 2;
            info[0] = 0;
            info[1] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Lateral - 2 ejes - papel
            info[0] = -1650;
            info[1] = -1870;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Papel, n, info);

            //Lateral - 2 ejes - vidrio
            info[0] = 0;
            info[1] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Lateral - 3 ejes - resto, org
            n = 3;
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
               (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Lateral - 3 ejes - envases
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Lateral - 3 ejes - vidrio
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            //Lateral - 3 ejes - papel
            info[0] = -2310;
            info[1] = -2530;
            info[2] = -2860;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Lateral,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Papel, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Superior - 2 ejes - resto, org
            n = 2;
            info[0] = 0;
            info[1] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
               (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Superior - 2 ejes - envases
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Superior - 2 ejes - vidrio
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Vidrio, n, info);


            //Superior - 2 ejes - papel
            info[0] = -1760;
            info[1] = -1870;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Papel, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Superior - 3 ejes - resto, org
            n = 3;
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
               (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Superior - 2 ejes - envases
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Superior - 2 ejes - vidrio
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Vidrio, n, info);


            //Superior - 3 ejes - papel
            info[0] = -2200;
            info[1] = -2530;
            info[2] = -2750;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Papel, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Bilateral - 2 ejes - resto, org
            n = 3;
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Bilateral - 2 ejes - envases
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Bilateral - 2 ejes - vidrio
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Superior,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            //Bilateral - 2 ejes - papel
            info[0] = 1820;
            info[1] = 2080;
            info[2] = 2340;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Papel, n, info);

            //Bilateral - 2 ejes - vidrio
            info[0] = -140;
            info[1] = -160;
            info[2] = -180;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            ////////////////////////////////////////////////////////////////////////////////////////////////
            //Bilateral - 3 ejes - resto, org
            n = 3;
            info[0] = 0;
            info[1] = 0;
            info[2] = 0;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Organica, n, info);
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes2, (int)RecogidaDef.TiposFracción.Resto, n, info);

            //Bilateral - 3 ejes - envases
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Envases, n, info);

            //Bilateral - 3 ejes - vidrio
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Vidrio, n, info);

            //Bilateral - 3 ejes - papel
            info[0] = -2200;
            info[1] = -2530;
            info[2] = -2860;
            rellena_carg_offset((int)RecogidaDef.TiposCarga.Bilateral,
                (int)RecogidaDef.TiposVehic.Ejes3, (int)RecogidaDef.TiposFracción.Papel, n, info);

        }

        }
    }