#region Usings

using System;
using System.Collections;
using System.Xml;
using System.Xml.Schema;
using System.Globalization;
using System.IO;
using System.Configuration;

using System.Reflection;

#endregion Usings

namespace Reportes
{
	
	/// <summary>
	/// Clase que representa un archivo de Información de Prestaciones Realizadas enviado por el 
	/// Prestador.
	/// </summary>
	public class InfoPrestacionesReport
	{
		#region Constructores

		public InfoPrestacionesReport( string pathNombreArchivo )
		{
			this._pathArchivo = pathNombreArchivo;
		}

		#endregion Constructores

		#region Campos Privados

		private string _pathArchivo = string.Empty;
		private string _cuitPrestador;
		private DateTime _fechaEnvio;

		private LineaInfoPrestacionesReport[] _lineas = null;

		#endregion Campos Privados

		#region Propiedades Públicas
		
		public string PathArchivo
		{
			get { return this._pathArchivo; }
			set { this._pathArchivo = value; }
		}

		public string NombreArchivo
		{
			get { return this.PathArchivo.Substring(this.PathArchivo.LastIndexOf(Path.DirectorySeparatorChar) + 1); }
		}

		public ArrayList ErroresValidacion
		{
			get
			{
				return this._validationErrors;
			}
		}

		public string CuitPrestador
		{
			get { return this._cuitPrestador; }
			set { this._cuitPrestador = value; }
		}

		public DateTime FechaEnvio
		{
			get { return this._fechaEnvio; }
			set { this._fechaEnvio = value; }
		}

		public LineaInfoPrestacionesReport[] Lineas
		{
			get { return this._lineas; }
			set { this._lineas = value; }
		}

		#endregion Propiedades Públicas

		#region Métodos públicos

		public bool ValidarFormato()
		{
			XmlDocument xmlDoc = new System.Xml.XmlDocument();
			try
			{
				xmlDoc.Load( this._pathArchivo );
			}
			catch ( XmlException xmlEx )
			{
				this._validationErrors.Add( xmlEx.Message );
				return false;
			}
			
			if ( this.ValidarContraSchema( xmlDoc ) )
			{
				this.CargarXml( xmlDoc );
			}
			else
			{
				return false;
			}

			return true;
		}

		public void ValidarLineas( Dominio.Autorizaciones.Prestador prestador )
		{
			foreach ( LineaInfoPrestacionesReport linea in this._lineas )
			{
				linea.Validar( prestador );
			}
		}

		#endregion Métodos públicos

		#region Métodos privados

		private ArrayList _validationErrors = new ArrayList();

		private void valReader_ValidationEventHandler(object sender, ValidationEventArgs e)
		{
			this._validationErrors.Add( e.Message );
		}

		private string _xsdPathNombre = null;
		private string XsdPathNombre
		{
			get 
			{ 
				if ( this._xsdPathNombre == null )
				{
					string currentDir = Directory.GetCurrentDirectory();
					string xsdPath = Path.Combine( currentDir, ConfigurationSettings.AppSettings["DirectorioRecursos"] );
					if ( ! Directory.Exists(xsdPath) )
					{
						Directory.CreateDirectory( xsdPath );
					}

					return ( Path.Combine( xsdPath, "infoPrestaciones_schema.xsd" ) );
				}
				else
					return this._xsdPathNombre;
			}
		}

		private bool ValidarContraSchema( XmlDocument xmlDoc )
		{
			this._validationErrors.Clear();

			NameTable nt = new NameTable();
			XmlNamespaceManager nm = new XmlNamespaceManager( nt );
			XmlParserContext pc = new XmlParserContext( null, nm, null, XmlSpace.None );

			XmlValidatingReader valReader = new XmlValidatingReader( xmlDoc.OuterXml, XmlNodeType.Element, pc );

			valReader.Schemas.Add( string.Empty, this.XsdPathNombre );
			valReader.ValidationType = ValidationType.Schema;

			valReader.ValidationEventHandler += new ValidationEventHandler(valReader_ValidationEventHandler);

			while (valReader.Read()) { }

			valReader.Close();

			return (this._validationErrors.Count == 0) ;
		}

		/// <summary>
		/// Toma un xmlDoc valido contra el schema
		/// </summary>
		/// <param name="xmlDoc"></param>
		private void CargarXml( XmlDocument xmlDoc )
		{
			XmlNode root = xmlDoc["infoPrestaciones"];
			
			this.FechaEnvio = DateTime.Parse( root.Attributes["fechaEnvio"].InnerText );
			
			XmlElement prestador = root["prestador"];
			this.CuitPrestador = prestador["CUIT"].InnerText;
			
			XmlElement lineasXml = root["lineas"];
			if ( lineasXml.HasChildNodes )
			{
				this._lineas = new LineaInfoPrestacionesReport[ lineasXml.ChildNodes.Count ];
				
				XmlNode node; int cod; string tipoAut; int codAfiliado; string codPrestacion;
				DateTime fechaRealizacion; float porcentajeCobertura;

				NumberFormatInfo nfi = new NumberFormatInfo();
				nfi.NumberDecimalDigits = 2;
				nfi.NumberDecimalSeparator = ".";
				nfi.NumberGroupSeparator = ",";

				for ( int i = 0; i < lineasXml.ChildNodes.Count; i++ )
				{
					node = lineasXml.ChildNodes[i];
					cod = int.Parse( node.Attributes["codigoAutorizacion"].InnerText );
					tipoAut = node["tipoAutorizacion"].InnerText;
					codAfiliado = int.Parse( node["codigoAfiliado"].InnerText );
					codPrestacion = node["codigoPrestacion"].InnerText;
					fechaRealizacion = DateTime.Parse( node["fechaRealizacion"].InnerText );
					
					porcentajeCobertura = float.Parse( node["porcentajeCobertura"].InnerText.Trim(), nfi );
					
					this._lineas[i] = new LineaInfoPrestacionesReport( cod, tipoAut, codAfiliado, codPrestacion,
						fechaRealizacion, porcentajeCobertura );
				}
			}
		}

		#endregion Métodos privados
	}
}