using System;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using TSpdf.IO.Font.Constants;
using TSpdf.IO.Image;
using TSpdf.Kernel.Colors;
using TSpdf.Kernel.Font;
using TSpdf.Kernel.Geom;
using TSpdf.Kernel.Pdf.Canvas;
using TSpdf.Kernel.Pdf.Extgstate;
using TSpdf.Layout;
using TSpdf.Layout.Element;
using TSpdf.Layout.Properties;
using TSpdf.Layout.Splitting;
using static tsPDFUtilsCore.Enums;

namespace tsPDFUtilsCore
{
    public class Sellado
    {
        
        public async static Task<bool> SellaPDFAsync(Stream PdfOrigen, Stream PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar,  DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
        {
            bool Res = false;
            await Task.Factory.StartNew(() =>
            {
                Res = SellaPDF(PdfOrigen, PdfDestino, TextosAInsertar, ImagenesAInsertar,  dlgpr, cts, ConvertirPDFA, PDFAObligatorio);
            });
            return Res;
        }
        public static bool SellaPDF(Stream PdfOrigen, Stream PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
        {
            try
            {
                Progreso prg = new Progreso();
                if (dlgpr != null)
                {
                    prg.Estado = "Cargando Documento";
                    dlgpr.Invoke(prg);
                }


                Stream pdfLectura;

                if (ConvertirPDFA)
                {
                    try
                    {       
                        pdfLectura = Utilidades.crearPDFA(PdfOrigen);
                    }
                    catch (Exception ex)
                    {
                        if (PDFAObligatorio)
                        {
                            throw new Exception(ex.Message, ex);
                        }
                        else
                        {
                            PdfOrigen.Position = 0;
                            pdfLectura = PdfOrigen; 
                        }
                    }
                }
                else
                {
                    pdfLectura = PdfOrigen;
                }


                TSpdf.Kernel.Pdf.PdfReader reader = new TSpdf.Kernel.Pdf.PdfReader(pdfLectura);
                reader.SetUnethicalReading(true);

                TSpdf.Kernel.Pdf.PdfWriter writer = new TSpdf.Kernel.Pdf.PdfWriter(PdfDestino);

                TSpdf.Kernel.Pdf.PdfDocument pdf = new TSpdf.Kernel.Pdf.PdfDocument(reader, writer);

                Document document = new Document(pdf);

                int numeroPaginas = pdf.GetNumberOfPages();
                    
                if (dlgpr != null)
                {

                    prg.NumeroPaginasTotal = numeroPaginas;
                    prg.Estado = "Sellando Documento";
                    dlgpr.Invoke(prg);
                }

                Image[] imagenes = null;
                if (ImagenesAInsertar != null)
                {
                    imagenes = new Image[ImagenesAInsertar.Count];
                    for (int k = 0; k < ImagenesAInsertar.Count; k++)
                    {
                        if (cts != null && cts.Token.IsCancellationRequested) return false;
                        ImageData imageData = ImageDataFactory.Create(ImagenesAInsertar[k].Imagen);
                        imagenes[k] = new Image(imageData);
                    }
                }


                for (int i = 1; i <= numeroPaginas; i++)
                {
                    if (cts != null && cts.Token.IsCancellationRequested) return false;
                    if (dlgpr != null)
                    {
                        prg.NumeroPaginaActual = i;
                        prg.Estado = "Procesando Página " + i.ToString() + " / " + prg.NumeroPaginasTotal.ToString();
                        dlgpr.Invoke(prg);
                    }
                    if (TextosAInsertar != null)
                    {
                        for (int j = 0; j < TextosAInsertar.Count; j++)
                        {
                            if (cts != null && cts.Token.IsCancellationRequested) return false;
                            if (TextosAInsertar[j].PaginaInicio <= i && (TextosAInsertar[j].PaginaFin >= i || TextosAInsertar[j].PaginaFin == 0))
                            {
                                controlarTextos(pdf, TextosAInsertar[j],i,numeroPaginas);
                            }
                        }
                    }
                    if (ImagenesAInsertar != null)
                    {
                        if (cts != null && cts.Token.IsCancellationRequested) return false;
                        for (int k = 0; k < ImagenesAInsertar.Count; k++)
                            if (ImagenesAInsertar[k].PaginaInicio <= i && (ImagenesAInsertar[k].PaginaFin >= i || ImagenesAInsertar[k].PaginaFin == 0))
                            {
                                controlarImagenes(pdf, ImagenesAInsertar[k],  i, imagenes[k]);
                            }
                    }
                }

                pdf.Close();
                document.Close();
                writer.Close();
                writer.Dispose();
                reader.Close();
                if (cts != null && cts.IsCancellationRequested)
                    return false;
                else return true;
            }
            catch (Exception ex)
            {
               throw new Exception(ex.Message,ex);
            }
        }
        public static bool SellaPDF(string PdfOrigen, string PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar,  DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
        {
            try
            {
                Progreso prg = new Progreso();
                if (dlgpr != null)
                {
                    prg.Estado = "Cargando Documento";
                    dlgpr.Invoke(prg);
                }

                Stream pdfLectura;
                if (ConvertirPDFA)
                {
                    FileStream fs = null;
                    try
                    {
                        fs = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read);
                        pdfLectura = Utilidades.crearPDFA(fs);
                    }
                    catch (Exception ex)
                    {
                        if (fs != null) fs.Close();
                        if(PDFAObligatorio)
                        {
                            throw new Exception(ex.Message,ex);                            
                        }
                        else
                        {
                            pdfLectura = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read);
                        }
                    }
                }
                else
                {
                    pdfLectura = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read);
                }

                TSpdf.Kernel.Pdf.PdfReader reader = new TSpdf.Kernel.Pdf.PdfReader(pdfLectura);
                reader.SetUnethicalReading(true);

                TSpdf.Kernel.Pdf.PdfWriter writer = new TSpdf.Kernel.Pdf.PdfWriter(PdfDestino);

                TSpdf.Kernel.Pdf.PdfDocument pdf = new TSpdf.Kernel.Pdf.PdfDocument(reader, writer);

                Document document = new Document(pdf);

                int numeroPaginas = pdf.GetNumberOfPages();

                if (dlgpr != null)
                {

                    prg.NumeroPaginasTotal = numeroPaginas;
                    prg.Estado = "Sellando Documento";
                    dlgpr.Invoke(prg);
                }

                Image[] imagenes = null;
                if (ImagenesAInsertar != null)
                {
                    imagenes = new Image[ImagenesAInsertar.Count];
                    for (int k = 0; k < ImagenesAInsertar.Count; k++)
                    {
                        if (cts != null && cts.Token.IsCancellationRequested) return false;
                        ImageData imageData = ImageDataFactory.Create(ImagenesAInsertar[k].Imagen);
                        imagenes[k] = new Image(imageData);
                    }
                }


                for (int i = 1; i <= numeroPaginas; i++)
                {
                    if (cts != null && cts.Token.IsCancellationRequested) return false;
                    if (dlgpr != null)
                    {
                        prg.NumeroPaginaActual = i;
                        prg.Estado = "Procesando Página " + i.ToString() + " / " + prg.NumeroPaginasTotal.ToString();
                        dlgpr.Invoke(prg);
                    }
                    if (TextosAInsertar != null)
                    {
                        for (int j = 0; j < TextosAInsertar.Count; j++)
                        {
                            if (cts != null && cts.Token.IsCancellationRequested) return false;
                            if (TextosAInsertar[j].PaginaInicio <= i && (TextosAInsertar[j].PaginaFin >= i || TextosAInsertar[j].PaginaFin == 0))
                            {
                                controlarTextos(pdf, TextosAInsertar[j], i, numeroPaginas);
                            }
                        }
                    }
                    if (ImagenesAInsertar != null)
                    {
                        if (cts != null && cts.Token.IsCancellationRequested) return false;
                        for (int k = 0; k < ImagenesAInsertar.Count; k++)
                            if (ImagenesAInsertar[k].PaginaInicio <= i && (ImagenesAInsertar[k].PaginaFin >= i || ImagenesAInsertar[k].PaginaFin == 0))
                            {
                                controlarImagenes(pdf, ImagenesAInsertar[k], i, imagenes[k]);
                            }
                    }
                }

                pdf.Close();
                document.Close();
                writer.Close();
                writer.Dispose();
                reader.Close();
                if (cts != null && cts.IsCancellationRequested)
                    return false;
                else return true;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);
            }

        }

        private static void controlarImagenes(TSpdf.Kernel.Pdf.PdfDocument pdf, ImagenEnPdf ImagenAInsertar, int numeroPagina, Image imagen)
        {
            TSpdf.Kernel.Pdf.PdfPage pagina = pdf.GetPage(numeroPagina);
            Rectangle tamanoPagina = pagina.GetPageSizeWithRotation();

            var anchoPagina = tamanoPagina.GetWidth();
            var altoPagina = tamanoPagina.GetHeight();

            // Cambia el ancho y alto de la página dependiendo de sus medidas
            tamanoPagina.SetWidth(comprobarAncho(anchoPagina, altoPagina, pagina.GetRotation()));
            tamanoPagina.SetHeight(comprobarAlto(anchoPagina, altoPagina, pagina.GetRotation()));

            var cropBoxPagina = pagina.GetCropBox();
            var mediaBox = pagina.GetMediaBox();

            Rectangle diferenciaTamano;
            if (mediaBox.GetWidth() != cropBoxPagina.GetWidth() || mediaBox.GetHeight() != cropBoxPagina.GetHeight())
            {
                diferenciaTamano = new Rectangle(cropBoxPagina.GetX() - mediaBox.GetX(), cropBoxPagina.GetY() - mediaBox.GetY(), mediaBox.GetWidth() - cropBoxPagina.GetWidth(), mediaBox.GetHeight() - cropBoxPagina.GetHeight());
            }
            else
            {
                diferenciaTamano = new Rectangle(cropBoxPagina.GetX(), cropBoxPagina.GetY(), mediaBox.GetWidth(), mediaBox.GetHeight());
            }

            PdfCanvas pdfCanvas = new PdfCanvas(pagina);
            PdfExtGState pdfExtGState = new PdfExtGState();
            pdfExtGState.SetFillOpacity((float)(1 - ImagenAInsertar.Transparencia));
            pdfExtGState.SetStrokeOpacity((float)(1 - ImagenAInsertar.Transparencia));
            pdfCanvas.SetExtGState(pdfExtGState);

            Canvas canvas = new Canvas(pdfCanvas, pagina.GetPageSizeWithRotation(), true);

            Image image = imagen.ScaleToFit(ImagenAInsertar.EscalaHorizontal, ImagenAInsertar.EscalaVertical).SetRotationAngle(ImagenAInsertar.AnguloRotacion);

            // Suma del ángulo del texto + el ángulo de la página, para que el ángulo final sea el correcto.
            float anguloImgPag = ((ImagenAInsertar.AnguloRotacion + pagina.GetRotation()));

            medidasTextoImagen medidasImagenInsertar = comprobarMedidasImagen(pagina.GetRotation(), ImagenAInsertar,  anguloImgPag,image);

            var distanciaX = calcularDistanciaX((int)ImagenAInsertar.EsquinaReferencia, tamanoPagina, ImagenAInsertar.CoordenadaX, medidasImagenInsertar.ancho, medidasImagenInsertar.alto, anguloImgPag, pagina.GetRotation(), diferenciaTamano);
            var distanciaY = calcularDistanciaY((int)ImagenAInsertar.EsquinaReferencia, tamanoPagina, ImagenAInsertar.CoordenadaY, medidasImagenInsertar.ancho, medidasImagenInsertar.alto, anguloImgPag, pagina.GetRotation(), diferenciaTamano);


            canvas.Add(image.SetFixedPosition(distanciaX
           , distanciaY
           )
          .SetRotationAngle((ImagenAInsertar.AnguloRotacion + pagina.GetRotation()) * (float)0.017453));


            canvas.Close();
        }
        private static void controlarTextos(TSpdf.Kernel.Pdf.PdfDocument pdf, TextoEnPdf TextoAInsertar, int numeroPagina, int totalNumeroPagina)
        {
            TSpdf.Kernel.Pdf.PdfPage pagina = pdf.GetPage(numeroPagina);


            Rectangle tamanoPagina = pagina.GetPageSizeWithRotation();

            var anchoPagina = tamanoPagina.GetWidth();
            var altoPagina = tamanoPagina.GetHeight();

            // Cambia el ancho y alto de la página dependiendo de sus medidas
            tamanoPagina.SetWidth(comprobarAncho(anchoPagina, altoPagina, pagina.GetRotation()));
            tamanoPagina.SetHeight(comprobarAlto(anchoPagina, altoPagina, pagina.GetRotation()));

            var cropBoxPagina = pagina.GetCropBox();
            var mediaBox = pagina.GetMediaBox();
            PdfCanvas pdfCanvas = new PdfCanvas(pagina);

            // Suma del ángulo del texto + el ángulo de la página, para que el ángulo final sea el correcto.
            float anguloTextPag = (TextoAInsertar.AnguloRotacion + pagina.GetRotation());


            Rectangle diferenciaTamano;
            if (mediaBox.GetWidth() != cropBoxPagina.GetWidth() || mediaBox.GetHeight() != cropBoxPagina.GetHeight())
            {
                diferenciaTamano = new Rectangle(cropBoxPagina.GetX() - mediaBox.GetX(), cropBoxPagina.GetY() - mediaBox.GetY(), mediaBox.GetWidth() - cropBoxPagina.GetWidth(), mediaBox.GetHeight() - cropBoxPagina.GetHeight());
            }
            else
            {
                diferenciaTamano = new Rectangle(cropBoxPagina.GetX(), cropBoxPagina.GetY(), mediaBox.GetWidth(), mediaBox.GetHeight());
            }

            PdfExtGState pdfExtGState = new PdfExtGState();
            pdfExtGState.SetFillOpacity((float)(1 - TextoAInsertar.Transparencia));
            pdfCanvas.SetExtGState(pdfExtGState);
            Canvas canvas = new Canvas(pdfCanvas, pagina.GetPageSizeWithRotation(), true);
            Paragraph texto = new Paragraph(TextoAInsertar.Texto)
                .SetWidth(TextoAInsertar.anchoTexto)
                .SetHeight(TextoAInsertar.altoTexto)
                .SetRotationAngle(anguloTextPag * (float)0.017453)
                //.SetBackgroundColor(new DeviceRgb(TextoAInsertar.Color.R, TextoAInsertar.Color.G, TextoAInsertar.Color.B))
                .SetTextAlignment(devolverAlineamiento((int)TextoAInsertar.Alineamiento));

            canvas.SetFont(devolverTipoFuente(TextoAInsertar.Fuente.ToString()));
            canvas.SetFontSize(TextoAInsertar.TamañoFuente);
            canvas.SetFontColor(new DeviceRgb(TextoAInsertar.Color.R, TextoAInsertar.Color.G, TextoAInsertar.Color.B));

            // Controla como se muestra el número de páginas
            switch (TextoAInsertar.TipoTexto)
            {
                case TipoTextoEnum.NUMERO_PAGINA_TOTAL_PAGINAS:
                    TextoAInsertar.Texto = "PAG " + numeroPagina.ToString().PadLeft(4, '0') + "/" + totalNumeroPagina.ToString().PadLeft(4, '0');
                    texto = new Paragraph(TextoAInsertar.Texto)
                        .SetWidth(TextoAInsertar.anchoTexto)
                        .SetHeight(TextoAInsertar.altoTexto)
                /* Resultado de fórmula matemática(pi/180º) para que el
                             ángulo sea el correcto */
                .SetRotationAngle(anguloTextPag * (float)0.017453)
                .SetTextAlignment(devolverAlineamiento((int)TextoAInsertar.Alineamiento));
                    break;
            }

            medidasTextoImagen medidasTextoInsertar =  comprobarMedidasTexto(pagina.GetRotation(), TextoAInsertar, anguloTextPag);

            canvas.ShowTextAligned(texto,
              calcularDistanciaX((int)TextoAInsertar.EsquinaReferencia, tamanoPagina, comprobarEjeXPagRotada(TextoAInsertar.CoordenadaX, TextoAInsertar.CoordenadaY, pagina.GetRotation()), medidasTextoInsertar.ancho, medidasTextoInsertar.alto, anguloTextPag, pagina.GetRotation(), diferenciaTamano),
              calcularDistanciaY((int)TextoAInsertar.EsquinaReferencia, tamanoPagina, comprobarEjeYPagRotada(TextoAInsertar.CoordenadaX, TextoAInsertar.CoordenadaY, pagina.GetRotation()), medidasTextoInsertar.ancho, medidasTextoInsertar.alto, anguloTextPag, pagina.GetRotation(), diferenciaTamano),
              devolverAlineamiento((int)TextoAInsertar.Alineamiento));

            canvas.Close();
        }
        public static medidasTextoImagen comprobarMedidasTexto(int rotacionPagina, TextoEnPdf TextoAInsertar, float anguloTextPag)
        {
            medidasTextoImagen medidas = new medidasTextoImagen();

            switch (rotacionPagina)
            {
                case 0:
                    if (TextoAInsertar.AnguloRotacion != 0)
                    {
                        medidas.ancho = 0;
                        medidas.alto = 0;
                    }
                    else
                    {
                        if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_DERECHA || TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                        else
                        {
                            if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
                            {
                                if (TextoAInsertar.AnguloRotacion == 0)
                                {
                                    medidas.alto = TextoAInsertar.altoTexto;
                                }
                                else
                                {
                                    medidas.ancho = TextoAInsertar.anchoTexto;
                                }
                            }
                            else
                            {
                                medidas.ancho = TextoAInsertar.anchoTexto;
                                medidas.alto = TextoAInsertar.altoTexto;
                            }

                        }

                    }

                    break;
                case 90:
                    if (TextoAInsertar.AnguloRotacion != 0)
                    {
                        if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA || TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
                        {
                            medidas.ancho = TextoAInsertar.anchoTexto;
                        }
                        else
                        {
                            medidas.ancho = TextoAInsertar.anchoTexto;
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                    }
                    else
                    {
                        if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA || TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                            medidas.ancho = TextoAInsertar.anchoTexto;
                        }
                        else
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                    }
                    break;
                case 180:
                    if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA)
                    {
                        if (anguloTextPag == 270)
                        {
                            medidas.ancho = TextoAInsertar.altoTexto;
                            medidas.alto = TextoAInsertar.anchoTexto;
                        }
                        else
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                    }
                    else if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
                    {
                        if (anguloTextPag == 180)
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                        else
                        {
                            medidas.ancho = TextoAInsertar.altoTexto;
                        }
                    }
                    else if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
                    {
                        if (anguloTextPag == 180)
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                            medidas.ancho = TextoAInsertar.anchoTexto;
                        }
                        else
                        {
                            medidas.ancho = TextoAInsertar.altoTexto;
                        }
                    }
                    else
                    {
                        medidas.ancho = TextoAInsertar.anchoTexto;
                        medidas.alto = TextoAInsertar.altoTexto;
                    }

                    break;
                case 270:

                    if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
                    {
                        if (TextoAInsertar.AnguloRotacion == 90)
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                        else
                        {
                            medidas.ancho = TextoAInsertar.anchoTexto;
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                    }
                    if (TextoAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
                    {
                        if (TextoAInsertar.AnguloRotacion == 90)
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                        else
                        {
                            medidas.ancho = TextoAInsertar.anchoTexto;

                        }
                    }
                    else if (TextoAInsertar.EsquinaReferencia != EsquinaEnum.SUPERIOR_DERECHA)
                    {
                        if (TextoAInsertar.AnguloRotacion == 0)
                        {
                            medidas.ancho = TextoAInsertar.anchoTexto;
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                        else
                        {
                            medidas.alto = TextoAInsertar.altoTexto;
                        }
                    }
                    break;
            }


            return medidas;
        }
        public static medidasTextoImagen comprobarMedidasImagen(int rotacionPagina, ImagenEnPdf ImagenAInsertar,  float anguloImgPag, Image image)
        {
            medidasTextoImagen medidas = new medidasTextoImagen();

            switch (rotacionPagina)
            {
                case 0:
                    if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA || ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_DERECHA)
                    {
                        medidas.alto = image.GetImageScaledHeight();
                        medidas.ancho = image.GetImageScaledWidth();
                    }
                    if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
                    {
                        if (ImagenAInsertar.AnguloRotacion == 0)
                        {
                            medidas.alto = image.GetImageScaledHeight();
                        }
                        else
                        {
                            medidas.ancho = image.GetImageScaledWidth();
                            medidas.alto = image.GetImageScaledHeight();
                        }
                    }
                    else
                    {
                        medidas.alto = image.GetImageScaledHeight();
                    }
                    break;
                case 90:
                    switch (anguloImgPag)
                    {
                        case 180:
                            if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_DERECHA || ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA)
                            {
                                medidas.alto = image.GetImageScaledHeight();
                                medidas.ancho = image.GetImageScaledWidth();
                            }
                            else
                            {
                                medidas.alto = image.GetImageScaledHeight();
                            }
                            break;

                        case 90:
                            if (ImagenAInsertar.EsquinaReferencia != EsquinaEnum.SUPERIOR_IZQUIERDA)
                            {
                                if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
                                {
                                    medidas.ancho = image.GetImageScaledWidth();
                                }
                                else
                                {
                                    medidas.alto = image.GetImageScaledHeight();
                                }

                                if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_DERECHA)
                                {
                                    medidas.ancho = image.GetImageScaledWidth();
                                    medidas.alto = image.GetImageScaledHeight();
                                }
                            }
                            break;
                        default:
                            medidas.ancho = image.GetImageScaledWidth();
                            medidas.alto = image.GetImageScaledHeight();
                            break;
                    }
                    break;
                case 180:
                    if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA)
                    {
                        if (anguloImgPag == 270)
                        {
                            medidas.ancho = image.GetImageScaledHeight();
                        }
                        else if (anguloImgPag != 180)
                        {
                            medidas.alto = image.GetImageScaledHeight();

                        }
                        else
                        {
                            medidas.ancho = image.GetImageScaledWidth();
                        }
                    }

                    if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
                    {
                        if (anguloImgPag == 270)
                        {
                            medidas.alto = image.GetImageScaledWidth();
                            medidas.ancho = image.GetImageScaledHeight();
                        }
                        else if (anguloImgPag == 180)
                        {
                            medidas.alto = image.GetImageScaledHeight();
                            medidas.ancho = image.GetImageScaledWidth();
                        }
                    }

                    if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
                    {
                        if (anguloImgPag == 270)
                        {
                            medidas.alto = image.GetImageScaledWidth();
                        }
                        else if (anguloImgPag == 180)
                        {
                            medidas.alto = image.GetImageScaledHeight();
                        }
                    }
                    break;
                case 270:
                    if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.INFERIOR_IZQUIERDA || ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_IZQUIERDA)
                    {
                        if (anguloImgPag == 360)
                        {
                            medidas.alto = image.GetImageScaledHeight();
                            medidas.ancho = image.GetImageScaledWidth();
                        }
                        else
                        {
                            medidas.alto = image.GetImageScaledHeight();
                        }
                    }
                    else
                    {
                        if (ImagenAInsertar.EsquinaReferencia == EsquinaEnum.SUPERIOR_DERECHA)
                        {
                            medidas.ancho = image.GetImageScaledWidth();
                            if (ImagenAInsertar.AnguloRotacion == 0)
                            {
                                medidas.alto = image.GetImageScaledHeight();
                            }
                        }
                        else if (ImagenAInsertar.AnguloRotacion != 90)
                        {
                            medidas.ancho = image.GetImageScaledWidth();
                            medidas.alto = image.GetImageScaledHeight();
                        }
                    }
                    break;
            }

            return medidas;
        }
        public static float PuntosAMilimetros(float puntos)
        {
            float valorPunto = 2.83465f;
            return puntos / valorPunto;
        }
        public static float comprobarEjeXPagRotada(float ejeX, float ejeY, float angulo)
        {
            float resultado = 0;

            if (angulo == 90 || angulo == 270)
            {
                ejeX = ejeY;
            }

            resultado = ejeX;

            return resultado;
        }
        public static float comprobarEjeYPagRotada(float ejeX, float ejeY, float angulo)
        {
            float resultado = 0;

            if (angulo == 90 || angulo == 270)
            {
                ejeY = ejeX;
            }

            resultado = ejeY;

            return resultado;
        }
        public static float comprobarAncho(float ancho, float alto, float angulo)
        {
            float resultado = 0;

            if (angulo == 90 || angulo == 270)
            {
                ancho = alto;
            }
            resultado = ancho;

            return resultado;
        }
        public static float comprobarAlto(float ancho, float alto, float angulo)
        {
            float resultado = 0;

            if (angulo == 90 || angulo == 270)
            {
                alto = ancho;
            }

            resultado = alto;

            return resultado;
        }
        public async static Task<bool> SellaPDFAsync(string PdfOrigen, string PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
        {
            FileStream fsR = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read, FileShare.Read);
            FileStream fsW = new FileStream(PdfDestino, FileMode.Create, FileAccess.Write, FileShare.None);
            Task<bool> t;
            t = SellaPDFAsync(fsR, fsW, TextosAInsertar, ImagenesAInsertar, dlgpr, cts,ConvertirPDFA,PDFAObligatorio);
            await t;
            return t.Result;
        }
        public static void SellaPDF(string PdfOrigen, string PdfDestino, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
        {


            FileStream fsR = new FileStream(PdfOrigen, FileMode.Open, FileAccess.Read, FileShare.Read);
            FileStream fsW = new FileStream(PdfDestino, FileMode.Create, FileAccess.Write, FileShare.None);
            SellaPDF(fsR, fsW, TextosAInsertar, ImagenesAInsertar,  dlgpr,ConvertirPDFA:ConvertirPDFA,PDFAObligatorio:PDFAObligatorio);
        }
        public static async Task<Stream> SellaPDFAsync(Stream PdfOrigen, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA=false)
        {

            MemoryStream ms = new MemoryStream();
            await Task.Factory.StartNew(() => SellaPDFAsync(PdfOrigen, ms, TextosAInsertar, ImagenesAInsertar, dlgpr, cts, ConvertirPDFA: ConvertirPDFA));
            return ms;
        }
        public static Stream SellaPDF(Stream PdfOrigen, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
        {

            MemoryStream ms = new MemoryStream();
            SellaPDF(PdfOrigen, ms, TextosAInsertar, ImagenesAInsertar, dlgpr,ConvertirPDFA: ConvertirPDFA, PDFAObligatorio: PDFAObligatorio);
            return ms;
        }
        public static async Task<Stream> SellaPDFAsync(String PdfOrigen, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, CancellationTokenSource cts = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
        {

            MemoryStream ms = new MemoryStream();
            MemoryStream mso = new MemoryStream(System.IO.File.ReadAllBytes(PdfOrigen));
            await Task.Factory.StartNew(() => SellaPDFAsync(mso, ms, TextosAInsertar, ImagenesAInsertar,  dlgpr, cts, ConvertirPDFA: ConvertirPDFA, PDFAObligatorio: PDFAObligatorio));
            return ms;
        }
        public static Stream SellaPDF(String PdfOrigen, List<TextoEnPdf> TextosAInsertar, List<ImagenEnPdf> ImagenesAInsertar, DelegadoProgreso dlgpr = null, bool ConvertirPDFA = false, bool PDFAObligatorio=false)
        {


            MemoryStream ms = new MemoryStream();
            MemoryStream mso = new MemoryStream(System.IO.File.ReadAllBytes(PdfOrigen));
            SellaPDF(mso, ms, TextosAInsertar, ImagenesAInsertar,  dlgpr, ConvertirPDFA: ConvertirPDFA, PDFAObligatorio: PDFAObligatorio);
            return ms;
        }
        public static float calcularDistanciaX(int esquina, Rectangle tamanoPagina, float coordenada, float anchoImagen, float altoImagen, float anguloImagen, float anguloPagina, Rectangle cropBoxPagina)
        {
            float distanciaX = 0;

            float anchoImagenOrig = anchoImagen;
            float altoImagenOrig = altoImagen;

            float diferenciaAncho = 0;
            float diferenciaAlto = 0;

            if (tamanoPagina.GetWidth() != cropBoxPagina.GetWidth())
            {
                diferenciaAncho = tamanoPagina.GetWidth() - cropBoxPagina.GetWidth();
            }
            else
            {
                diferenciaAncho = cropBoxPagina.GetWidth();
            }

            if (tamanoPagina.GetHeight() != cropBoxPagina.GetHeight())
            {
                diferenciaAlto = tamanoPagina.GetHeight() - cropBoxPagina.GetHeight();
            }
            else
            {
                diferenciaAlto = cropBoxPagina.GetHeight();
            }

            switch (esquina)
            {
                case 0:
                    switch (anguloImagen)
                    {
                        case 90:
                            if (anguloPagina == 90)
                            {
                                distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + altoImagen);
                            }
                            else
                            {
                                distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada);
                            }
                            break;

                        case 180:
                            if (anguloPagina == 90)
                            {
                                distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagenOrig);
                            }
                            else if (anguloPagina == 180)
                            {
                                distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagen);
                            }
                            else
                            {
                                distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada);
                            }
                            break;

                        case 270:
                            if (anguloPagina == 180)
                            {
                                distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagen);
                            }
                            else
                            {
                                distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada) + altoImagen;
                            }
                            break;

                        case 360:
                            distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada));
                            break;

                        default:
                            distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada) - anchoImagenOrig;
                            break;
                    }
                    break;

                case 1:
                    switch (anguloImagen)
                    {
                        case 0:
                            distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (anchoImagenOrig + PuntosAMilimetros(coordenada));
                            break;
                        case 90:

                            if (anguloPagina == 90)
                            {
                                distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (altoImagenOrig + PuntosAMilimetros(coordenada));
                            }
                            else
                            {
                                distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (altoImagenOrig + PuntosAMilimetros(coordenada));
                            }

                            break;

                        case 180:
                            anchoImagen = altoImagen;

                            if (anguloPagina == 90)
                            {

                                distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (anchoImagenOrig + PuntosAMilimetros(coordenada));
                            }
                            else if (anguloPagina == 180)
                            {
                                distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - anchoImagenOrig);
                            }
                            else
                            {
                                distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (anchoImagen + PuntosAMilimetros(coordenada));
                            }
                            break;

                        case 270:
                            if (anguloPagina == 270)
                            {
                                distanciaX = (PuntosAMilimetros(coordenada) + cropBoxPagina.GetX());
                            }
                            else if (anguloPagina == 180)
                            {
                                distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - altoImagen);
                            }
                            break;
                        case 360:
                            distanciaX = (PuntosAMilimetros(coordenada + anchoImagenOrig) + cropBoxPagina.GetX());
                            break;

                        default:
                            distanciaX = (diferenciaAncho + tamanoPagina.GetX()) - (anchoImagen + PuntosAMilimetros(coordenada));

                            break;
                    }
                    break;

                case 2:
                    switch (anguloImagen)
                    {
                        case 90:
                            if (anguloPagina == 90)
                            {
                                if (PuntosAMilimetros(coordenada) < altoImagenOrig)
                                {
                                    distanciaX = cropBoxPagina.GetX() + altoImagenOrig - PuntosAMilimetros(coordenada);
                                }
                                else
                                {
                                    distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada) - altoImagenOrig;
                                }
                            }
                            else
                            {
                                distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada);
                            }

                            break;
                        case 180:
                            if (anguloPagina == 180)
                            {
                                distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagen);
                            }
                            else
                            {
                                distanciaX = cropBoxPagina.GetX() + PuntosAMilimetros(coordenada) - anchoImagenOrig;
                            }
                            break;
                        case 270:
                            if (anguloPagina == 180)
                            {

                                distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (PuntosAMilimetros(coordenada) + anchoImagen);
                            }
                            else
                            {
                                distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (altoImagenOrig + PuntosAMilimetros(coordenada));
                            }
                            break;
                        case 360:
                            distanciaX = (diferenciaAncho + cropBoxPagina.GetX()) - (anchoImagenOrig + PuntosAMilimetros(coordenada));
                            break;
                        default:
                            distanciaX = (PuntosAMilimetros(coordenada) + anchoImagenOrig) + cropBoxPagina.GetX();
                            break;
                    }
                    break;

                case 3:
                    switch (anguloImagen)
                    {
                        case 90:
                            if (anguloPagina == 90)
                            {
                                if (PuntosAMilimetros(coordenada) > altoImagenOrig)
                                {
                                    distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada));
                                }
                                else
                                {
                                    distanciaX = cropBoxPagina.GetX() + (altoImagenOrig + PuntosAMilimetros(coordenada));
                                }
                            }
                            else if (anguloPagina == 0)
                            {
                                distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (altoImagenOrig + PuntosAMilimetros(coordenada));
                            }
                            break;

                        case 180:

                            if (anguloPagina == 180)
                            {
                                distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - anchoImagen);
                            }
                            else
                            {
                                if (PuntosAMilimetros(coordenada) > anchoImagenOrig)
                                {
                                    distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - anchoImagenOrig);
                                }
                                else
                                {
                                    distanciaX = cropBoxPagina.GetX() + (anchoImagenOrig - PuntosAMilimetros(coordenada));
                                }
                            }

                            break;

                        case 270:
                            if (anguloPagina == 180)
                            {
                                distanciaX = cropBoxPagina.GetX() + (PuntosAMilimetros(coordenada) - anchoImagen);
                            }
                            else
                            {
                                distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (altoImagen + PuntosAMilimetros(coordenada));
                            }
                            break;

                        case 360:
                            distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (anchoImagenOrig + PuntosAMilimetros(coordenada));
                            break;

                        default:
                            distanciaX = cropBoxPagina.GetX() + diferenciaAncho - (anchoImagen + PuntosAMilimetros(coordenada));
                            break;
                    }
                    break;
            }

            return distanciaX;
        }
        public static float calcularDistanciaY(int esquina, Rectangle tamanoPagina, float coordenada, float anchoImagen, float altoImagen, float anguloImagen, float anguloPagina, Rectangle cropBoxPagina)
        {
            float distanciaY = 0;
            float anchoImagenOrig = anchoImagen;
            float altoImagenOrig = altoImagen;

            float diferenciaAncho = 0;
            float diferenciaAlto = 0;

            if (tamanoPagina.GetWidth() != cropBoxPagina.GetWidth())
            {
                diferenciaAncho = tamanoPagina.GetWidth() - cropBoxPagina.GetWidth();
            }
            else
            {
                diferenciaAncho = cropBoxPagina.GetWidth();
            }

            if (tamanoPagina.GetHeight() != cropBoxPagina.GetHeight())
            {
                diferenciaAlto = tamanoPagina.GetHeight() - cropBoxPagina.GetHeight();
            }
            else
            {
                diferenciaAlto = cropBoxPagina.GetHeight();
            }
            switch (esquina)
            {
                case 0:
                    switch (anguloImagen)
                    {
                        case 90:
                            if (anguloPagina == 90)
                            {
                                distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) - anchoImagen;
                            }
                            else
                            {
                                distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada);
                            }
                            break;

                        case 180:
                            if (anguloPagina == 90)
                            {
                                distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) + altoImagenOrig;
                            }
                            else if (anguloPagina == 180)
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
                            }
                            else

                            {
                                distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada);
                            }
                            break;

                        case 270:
                            if (anguloPagina == 180)
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
                            }
                            else
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
                            }
                            break;

                        case 360:
                            distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
                            break;
                        default:
                            distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada);
                            break;
                    }
                    break;

                case 1:
                    switch (anguloImagen)
                    {
                        case 90:
                            if (anguloPagina == 90)
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (anchoImagenOrig + PuntosAMilimetros(coordenada));
                            }
                            else
                            {

                                distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada);
                            }
                            break;
                        case 180:

                            if (anguloPagina == 90)
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada));
                            }
                            else if (anguloPagina == 180)
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada) + altoImagenOrig);
                            }
                            else
                            {
                                distanciaY = cropBoxPagina.GetY() + (anchoImagenOrig + PuntosAMilimetros(coordenada));
                            }

                            break;
                        case 270:
                            if (anguloPagina == 270)
                            {
                                if ((PuntosAMilimetros(coordenada) < anchoImagenOrig))
                                {
                                    distanciaY = cropBoxPagina.GetY() + anchoImagenOrig + (PuntosAMilimetros(coordenada));
                                }
                                else
                                {
                                    distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) - anchoImagenOrig);
                                }

                            }
                            else if (anguloPagina == 180)
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada) + anchoImagen);

                            }
                            break;
                        case 360:
                            distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) - altoImagenOrig);
                            break;

                        default:
                            distanciaY = PuntosAMilimetros(coordenada) + cropBoxPagina.GetY();
                            break;
                    }
                    break;

                case 2:

                    switch (anguloImagen)
                    {
                        case 90:
                            if (anguloPagina == 90)
                            {
                                distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) - anchoImagenOrig);
                            }
                            else
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (anchoImagenOrig + PuntosAMilimetros(coordenada));
                            }
                            break;

                        case 180:
                            if (anguloPagina == 180)
                            {
                                distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) + altoImagen);
                            }
                            else
                            {
                                distanciaY = cropBoxPagina.GetY() + (altoImagenOrig + PuntosAMilimetros(coordenada));
                            }
                            break;
                        case 270:
                            if (anguloPagina == 180)
                            {
                                distanciaY = cropBoxPagina.GetY() + (PuntosAMilimetros(coordenada) + altoImagen);
                            }
                            else
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada));
                            }
                            break;

                        case 360:
                            distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagenOrig + PuntosAMilimetros(coordenada));

                            break;
                        default:
                            distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagenOrig + PuntosAMilimetros(coordenada));
                            break;
                    }

                    break;

                case 3:
                    switch (anguloImagen)
                    {
                        case 90:
                            altoImagen = anchoImagen;
                            distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
                            break;
                        case 180:
                            if (anguloPagina == 180)
                            {
                                distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) + altoImagen;
                            }
                            else
                            {
                                distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (PuntosAMilimetros(coordenada));
                            }
                            break;
                        case 270:
                            if (anguloPagina == 180)
                            {
                                distanciaY = cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) + altoImagen;
                            }
                            else
                            {
                                distanciaY = PuntosAMilimetros(coordenada) > anchoImagenOrig ? cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) - anchoImagenOrig : cropBoxPagina.GetY() + anchoImagenOrig + PuntosAMilimetros(coordenada);
                            }
                            break;
                        case 360:
                            distanciaY = PuntosAMilimetros(coordenada) > altoImagenOrig ? cropBoxPagina.GetY() + PuntosAMilimetros(coordenada) - altoImagenOrig : cropBoxPagina.GetY() + altoImagenOrig - PuntosAMilimetros(coordenada);
                            break;
                        default:
                            distanciaY = cropBoxPagina.GetY() + diferenciaAlto - (altoImagen + PuntosAMilimetros(coordenada));
                            break;
                    }
                    break;
            }

            return distanciaY;
        }
        public static string devolverDatosFecha(DateTime fecha, string datoADevolver)
        {

            string datoFecha = string.Empty;



            switch (datoADevolver.ToUpper())
            {

                case "DIA":

                    datoFecha = fecha.ToString("dd/MM/yyyy").Split('/')[0];

                    break;

                case "MES":

                    datoFecha = fecha.ToString("MMMM").ToUpper();


                    break;

                case "AÑO":

                    datoFecha = fecha.ToString("dd/MM/yyyy").Split('/')[2];
                    break;

            }
            return datoFecha;
        }
        public static string devolverDatos(string cadenaDatos, int seleccionarDato)
        {
            string datos = string.Empty;

            switch (seleccionarDato)
            {

                case 1:

                    datos = cadenaDatos.Split(' ')[0];

                    break;

                case 2:

                    datos = cadenaDatos.Split(' ')[1];

                    break;


                case 3:

                    datos = cadenaDatos.Split(' ')[2];

                    break;
            }



            return datos;


        }
        private static TextAlignment devolverAlineamiento(int alineamiento)
        {
            TextAlignment obtenerAlineamiento = new TextAlignment();

            switch (alineamiento)
            {
                case 0:
                    obtenerAlineamiento = TextAlignment.LEFT;
                    break;

                case 1:
                    obtenerAlineamiento = TextAlignment.RIGHT;
                    break;

                case 2:
                    obtenerAlineamiento = TextAlignment.CENTER;
                    break;

                case 3:
                    obtenerAlineamiento = TextAlignment.JUSTIFIED_ALL;
                    break;
            }

            return obtenerAlineamiento;

        }
        private static TSpdf.Kernel.Font.PdfFont devolverTipoFuente(string nombreFuente)
        {

            TSpdf.Kernel.Font.PdfFont tipoFuente;
            switch (nombreFuente)
            {
                case "COURIER":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.COURIER);
                    break;

                case "COURIER_BOLD":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.COURIER_BOLD);
                    break;

                case "COURIER_BOLDOBLIQUE":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.COURIER_BOLDOBLIQUE);
                    break;

                case "COURIER_OBLIQUE":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.COURIER_OBLIQUE);
                    break;

                case "HELVETICA":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.HELVETICA);
                    break;

                case "HELVETICA_BOLD":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.HELVETICA_BOLD);
                    break;

                case "HELVETICA_BOLDOBLIQUE":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.HELVETICA_BOLDOBLIQUE);
                    break;

                case "HELVETICA_OBLIQUE":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.HELVETICA_OBLIQUE);
                    break;

                case "SYMBOL":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.SYMBOL);
                    break;

                case "TIMES_ROMAN":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_ROMAN);
                    break;

                case "TIMES_BOLD":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_BOLD);
                    break;

                case "TIMES_BOLDITALIC":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_BOLDITALIC);
                    break;

                case "TIMES_ITALIC":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_ITALIC);
                    break;

                case "ZAPFDINGBATS":
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.ZAPFDINGBATS);
                    break;

                default:
                    tipoFuente = PdfFontFactory.CreateFont(StandardFonts.TIMES_ROMAN);
                    break;
            }

            return tipoFuente;
        }
        public delegate void DelegadoProgreso(Progreso progreso);
        public class Progreso
        {
            public int NumeroPaginasTotal { get; set; }
            public int NumeroPaginaActual { get; set; }
            public string Estado { get; set; }
        }
        public class medidasTextoImagen
        {
            public float ancho { get; set; }
            public float alto { get; set; }
        }

    }
}