using Database;
using Syncfusion.DocIO.DLS;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using Syncfusion.DocIO;
using Syncfusion.DocIO.DLS;

using Syncfusion.Pdf;
using Syncfusion.XlsIO;
using static System.Net.Mime.MediaTypeNames;
using Syncfusion.Pdf.Parsing;
using System.Xml.Linq;
using Model;
using SkiaSharp;
using System.Web;
using System.Net;
using System.Security.Policy;
using DOCGEN.Klassen;
using System.Data;
using Helper;
using Syncfusion.XlsIO.Parser.Biff_Records;
using System.Buffers.Text;
using Syncfusion.ExcelToPdfConverter;


namespace DOCGEN
{
    public class DocGet
    {
        private string connectionstring = "";
        private string URI = "https://localhost:44334/";

        public DocGet(string Connectionstring)
        {
            this.connectionstring = Connectionstring;
            Lic();
        }

        public void Lic()
        {
            Syncfusion.Licensing.SyncfusionLicenseProvider.RegisterLicense("MzYzODg2NkAzMjM4MmUzMDJlMzBTOWljRmxNelA1d1VGOHpGR0lxQzB6UTAwKzIxK2VBNEhBZFp5alcxb1NVPQ==");

        }
        public string test_filetype(string filename)
        {
            string b64 = ConvertFileToBase64(filename);
            var streamword = new MemoryStream(Convert.FromBase64String(b64));
            var streamexcel = new MemoryStream(Convert.FromBase64String(b64));

            try
            {
                if (Is_WordDocument(streamword) == true)
                {
                    return "Word";
                }
                if (Is_ExcelDocument(streamexcel) == true)
                {
                    return "Excel";
                }
                if (Is_PDFDocument(b64))
                {
                    return "PDF";
                }
            }
            catch
            {
                return "";
            }
            finally
            {
                streamword.Dispose();
                streamexcel.Dispose();
            }
            return "";
        }

        public string get_word_vorlage(int vorlagenr, int dokumenttypnr)
        {
            DB db = new DB(connectionstring);
            string sql = "Select dbo.BinaryToBase64(vorlage) as Data from office_vorlage_datei where office_vorlage_dateinr=" + vorlagenr;
            db.Get_Tabledata(sql, false, true);
            string base64 = db.dsdaten.Tables[0].Rows[0][0].ToString();
            MemoryStream ms = new MemoryStream(Helper.EncodeExtensions.DecodeBase642ByteArray(base64));
            WordDocument document = new WordDocument(ms, FormatType.Automatic);
            db.Get_Tabledata("Select isnull(CompatibilityMode,'') from dokumenttyp where dokumenttypnr=" + dokumenttypnr.ToString(), false, true);
            SyncFWord sfw = new SyncFWord("", "");
            sfw.set_compatibilitymode(ref document, db.dsdaten.Tables[0].Rows[0][0].ToString());
            sfw = null;
            var formattype_original = document.ActualFormatType;


            MemoryStream destms = new MemoryStream();
            if (formattype_original.ToString().ToUpper() == "DOTMXXX")
            {
                document.Save(destms, FormatType.Docm);
            }

            else
            {
                document.Save(destms, formattype_original);
            }

            document.Close();
            document.Dispose();
            byte[] imageArray = destms.ToArray();
            ms.Close();
            ms.Dispose();
            return Convert.ToBase64String(imageArray);
        }
        public string Get_FileType(string b64)
        {
            var streamword = new MemoryStream(Convert.FromBase64String(b64));
            var streamexcel = new MemoryStream(Convert.FromBase64String(b64));

            try
            {
                if (Is_WordDocument(streamword) == true)
                {
                    return "W";
                }
                if (Is_ExcelDocument(streamexcel) == true)
                {
                    return "X";
                }
                if (Is_PDFDocument(b64))
                {
                    return "P";
                }
            }
            catch
            {
                return "";
            }
            finally
            {
                streamword.Dispose();
                streamexcel.Dispose();
            }
            return "";
        }

        public clsdok GetDocAsFinalPDF(string DocID)
        {
            Database.DB db = new Database.DB(connectionstring);
            db.Get_Tabledata("select * from Relaunch_View_PDF_Parameter where dokumentid='" + DocID + "' order by sort", false, true);
            return GetDocAsPDF(DocID, db.dsdaten.Tables[0]);
        }
        public clsdok GetDocAsPDF(string Docid, DataTable pdfparameters = null)
        {
            clsdok dok = GetDoc(Docid);
          
                try
            {
                switch (dok.doktype.ToUpper().Substring(0, 1))
                {
                    case "D":
                        dok.dokument = Convert_Word_To_PDF(dok.dokument.ToString(), pdfparameters);
                        dok.extension = "pdf";
                        return dok;
                        break;
                    case "X":

                        dok.dokument = Convert_Excel_To_PDF(dok.dokument.ToString());
                        dok.extension = "pdf";
                        return dok;
                        break;
                    case "P":
                        return dok;
                        dok.extension = "pdf";
                        break;
                    default:
                        return dok;
                }
            }
            catch
            {
                return dok;
            }
            return dok;
        }
        public clsdok GetDoc(string Docid)
        {
            //if (URI !="")
            //{
            //    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(URI+ "api/GetDocument?dokid=" + Docid);
            //    request.Method = "GET";
            //    WebResponse response = (WebResponse)request.GetResponse();

            //}
            DB db = new DB(connectionstring);
            clsdok dok = new clsdok("", "", "","");
            dok = db.GetDocumentAsBase64(Docid);

            if (dok.doktype == "")
            {
                dok.doktype = Get_FileType(dok.dokument);
            }

            return dok;

        }

        public string ConvertFileToBase64(string fileName)
        {
            string ReturnValue = "";


            using (FileStream BinaryFile = new FileStream(fileName, FileMode.Open))
            {
                BinaryReader BinRead = new BinaryReader(BinaryFile);
                byte[] BinBytes = BinRead.ReadBytes(System.Convert.ToInt32(BinaryFile.Length));
                ReturnValue = Convert.ToBase64String(BinBytes);
                BinaryFile.Close();
            }

            return ReturnValue;
        }

        public string docfiletype { get; set; } = "";
        private bool Is_WordDocument(MemoryStream stream)
        {
            Syncfusion.DocIO.DLS.WordDocument WordDocument = new Syncfusion.DocIO.DLS.WordDocument();
            try
            {
                WordDocument.Open(stream, FormatType.Automatic);
                string type = "";
                type = WordDocument.ActualFormatType.ToString();
                docfiletype = type;
                return true;
            }
            catch
            {
                return false;
            }
            finally
            {
                WordDocument.Dispose();
                WordDocument = null;
            }
        }

        public string check_office_application(string source)
        {
            MemoryStream ms = new MemoryStream(Convert.FromBase64String(source));
            if (Is_WordDocument(ms))
            {
                ms.Close();
                ms = null;
                return "Word";
            }
            if (Is_ExcelDocument(ms))
            {
                ms.Close();
                ms = null;
                return "Excel";
            }
            return "";
        }

        private bool Is_ExcelDocument(MemoryStream stream)
        {
            ExcelEngine excelEngine = new ExcelEngine();
            IApplication application = excelEngine.Excel;
            //IWorkbook workbook = application.Workbooks.Open(stream);
            IWorkbook workbook;
            try
            {
                string type = "";
                workbook = application.Workbooks.Open(stream);
                type = workbook.Version.ToString();
                docfiletype = type;
                return true;
            }
            catch
            {
                return false;
            }
            finally
            {
                excelEngine.Dispose();
                workbook = null;
                application = null;
                excelEngine = null;
            }
        }

        private bool Is_PDFDocument(string b64)
        {
            PdfLoadedDocument LoadedDocument;
            try
            {
                LoadedDocument = new PdfLoadedDocument(Helper.EncodeExtensions.DecodeBase642ByteArray(b64));

                return true;

            }
            catch
            {
                return false;
            }
            finally
            {
                LoadedDocument = null;
            }
        }


        public string Convert_Word_To_PDF(string document, DataTable pdfparameters = null, bool useseettings = false)
        {
            
            //Dokument erstellen
            var streamword = new MemoryStream(Convert.FromBase64String(document));
            WordDocument wordDocument = new WordDocument(streamword, Syncfusion.DocIO.FormatType.Automatic);

           

            // Keine Parameter / Dokument als PDF konvertieren
            if (pdfparameters == null)
            {
                using (Syncfusion.DocToPDFConverter.DocToPDFConverter converter = new Syncfusion.DocToPDFConverter.DocToPDFConverter())
                {
                    converter.Settings.EmbedFonts = true;
                    if (useseettings)
                    {
                        converter.Settings.UpdateDocumentFields = false;
                        converter.Settings.EnableAlternateChunks = true;
                        converter.Settings.AutoDetectComplexScript = true;
                        converter.Settings.ImageResolution = 640;
                        converter.Settings.ImageQuality = 100;
                    }
                    else
                    {
                        converter.Settings.UpdateDocumentFields = false;
                        converter.Settings.EnableAlternateChunks = true;
                        converter.Settings.AutoDetectComplexScript = true;
                        converter.Settings.ImageResolution = 96;
                        converter.Settings.ImageQuality = 1;
                    }
                    //Converts Word document into PDF document
                    using (PdfDocument pdfDocument = converter.ConvertToPDF(wordDocument))
                    {
                        MemoryStream outputStream = new MemoryStream();
                        pdfDocument.Save(outputStream);
                        byte[] bytes;
                        bytes = outputStream.ToArray();
                        return Convert.ToBase64String(bytes);
                    }
                };
            }
            else
            {

                WordDocument[] words = new WordDocument[2];
                WordDocument[] finalwords = new WordDocument[3];
                bool splitted = false;
                SyncFWord sfword = new SyncFWord("","");
                // Texte ersetzen
                foreach (DataRow r in pdfparameters.Rows)
                {
                    // Text ersetzen im ganzen Dokument
                    if (r["Funktion"].ToString() == "1")
                    {
                        switch (r["OfficeElementType"].ToString())
                        {
                            case "2":
                                sfword.Replace_Fieldtext(ref wordDocument, r["OfficeElement"].ToString(), r["OfficeElementInhaltNeu"].ToString());
                                break;
                            case "3":
                                //Bookmarkcontent
                                break;
                            case "4":
                                sfword.Replace_Text(ref wordDocument, r["OfficeElementInhaltAlt"].ToString(), r["OfficeElementInhaltNeu"].ToString());
                                break;
                        }
                    }
                }
                //Split
                foreach (DataRow r in pdfparameters.Rows)
                {
                    if (r["Funktion"].ToString() == "2")
                    {
                        words[0] = new WordDocument();
                        words[1] = new WordDocument();
                            
                        sfword.SplitDocument(ref wordDocument,ref words[0], Convert.ToInt32(r["OfficeElementInhaltneu"]));
                        sfword.SplitDocument_Part2(ref wordDocument, ref words[1],  Convert.ToInt32(r["OfficeElementInhaltneu"]));
                        splitted= true;
                    }
                }
               

                if (splitted==false)
                {
                    finalwords[0] = words[0];
                }
                else
                {
                    finalwords[0]=words[0];
                    //Dokument kopieren
                    int copynr = 0;
                    foreach (DataRow r in pdfparameters.Rows)
                    {
                        if (Convert.ToInt32(r["Kopienummer"]) > copynr)
                        {
                            copynr = Convert.ToInt32(r["Kopienummer"]);
                            finalwords[copynr] = new WordDocument();
                            finalwords[copynr]= words[Convert.ToInt32(r["dokumentteil"]) - 1];
                            
                        }
                    }
                    foreach(DataRow r in pdfparameters.Rows)
                    {
                        if (r["Funktion"].ToString() == "3")
                        {
                            switch (r["OfficeElementType"].ToString())
                            {
                                case "2":
                                    wordDocument = finalwords[Convert.ToInt32(r["Kopienummer"])];
                                    sfword.Replace_Fieldtext(ref wordDocument, r["OfficeElement"].ToString(), r["OfficeElementInhaltNeu"].ToString());
                                    wordDocument.UpdateDocumentFields();
                                    finalwords[Convert.ToInt32(r["Kopienummer"])]=wordDocument;
                                    
                                    break;
                                case "3":
                                    //Bookmarkcontent
                                    break;
                                case "4":
                                    wordDocument = finalwords[Convert.ToInt32(r["Kopienummer"])];
                                    sfword.Replace_Text(ref wordDocument, r["OfficeElementInhaltAlt"].ToString(), r["OfficeElementInhaltNeu"].ToString());
                                    wordDocument.UpdateDocumentFields();
                                    finalwords[Convert.ToInt32(r["Kopienummer"])] = wordDocument;
                                    break;
                            }
                        }
                    }
                    PdfDocument finaldoc = new PdfDocument();
                    PdfDocument[] pdfs = new PdfDocument[finalwords.Length];
                    for (int i = 0; i< finalwords.Count(); i++)
                    {
                        using (Syncfusion.DocToPDFConverter.DocToPDFConverter converter = new Syncfusion.DocToPDFConverter.DocToPDFConverter())
                        {
                            wordDocument = finalwords[i];
                            converter.Settings.EmbedFonts = true;
                            pdfs[i] = new PdfDocument();
                            pdfs[i] = converter.ConvertToPDF(finalwords[i]);
                        };
                    }

                    MemoryStream[] streams = new MemoryStream[pdfs.Count()];
                    for (int i = 0; i< pdfs.Count(); i++)
                    {
                        streams[i] = new MemoryStream();    
                        pdfs[i].Save(streams[i]);
                    }
                    PdfDocumentBase.Merge(finaldoc,streams);
                    MemoryStream outputStream = new MemoryStream();
                    finaldoc.Save(outputStream);
                    finaldoc.Save(@"h:\tssettings\edoka\test.pdf");
                    byte[] bytes;
                    bytes = outputStream.ToArray();
                    return Convert.ToBase64String(bytes);


                }


                //Exemplare
                //foreach (DataRow r in pdfparameters.Rows)
                //{
                //    if (r["Funktion"].ToString() == "3")
                //    {
                //        words.Add(sfword.SplitDocument(wordDocument, Convert.ToInt32(r["OfficeElementInhaltneu"])));
                //        words.Add(sfword.SplitDocument_Part2(wordDocument, Convert.ToInt32(r["OfficeElementInhaltneu"])));
                //    }
                //}

                return "";
            }
        }

        public string Convert_Excel_To_PDF(string document)
        {
            try
            {
                using (ExcelEngine excelEngine = new ExcelEngine())
                {
                    IApplication application = excelEngine.Excel;
                    application.DefaultVersion = ExcelVersion.Xlsx;
                    var streamexcel = new MemoryStream(Convert.FromBase64String(document));
                    IWorkbook workbook = application.Workbooks.Open(streamexcel);

                    //Initialize ExcelToPdfConverter
                    ExcelToPdfConverter converter = new ExcelToPdfConverter(workbook);
                    ExcelToPdfConverterSettings settings = new ExcelToPdfConverterSettings();
                    settings.EmbedFonts = true;



                    //Initialize PDF document
                    PdfDocument pdfDocument = new PdfDocument();

                    //Convert Excel document into PDF document
                    pdfDocument = converter.Convert(settings);

                    //Save the converted PDF document

                    MemoryStream outputStream = new MemoryStream();
                    pdfDocument.Save(outputStream);
                    byte[] bytes;
                    bytes = outputStream.ToArray();
                    return Convert.ToBase64String(bytes);
                }
            }
            catch { }
            return "";
        }

        public void Print_Doc(string document)
        {
            SyncFWord sfword = new SyncFWord("","");
            sfword.Print_Word(document);

        }
    }

}