using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.Drawing.Imaging;
using System.Drawing.Printing;
using System.Windows.Forms;
using Microsoft.Reporting.WinForms;
using System.Configuration;
using SteamWare;
using C2P_Data;


using System.Net;
using System.Web;

/// <summary>
/// Classe che si occupa di stampare report da reportViewer via printer remota
/// </summary>
public class reportPrinter
{
    #region area codice da non modificare

    private int m_currentPageIndex;
    protected int logLevel = 0;
    protected bool doPdfCopy = false;
    /// <summary>
    /// stream del report...
    /// </summary>
    private IList<Stream> m_streams;
    /// <summary>
    /// ciclo da fornire al renderizzatore dei report, per salvare 1 immagine da ogni pagina del report
    /// </summary>
    /// <param name="name"></param>
    /// <param name="fileNameExtension"></param>
    /// <param name="encoding"></param>
    /// <param name="mimeType"></param>
    /// <param name="willSeek"></param>
    /// <returns></returns>
    private Stream CreateStream(string name, string fileNameExtension, Encoding encoding, string mimeType, bool willSeek)
    {
        // creo files con nomi univoci...
        string filePathName = string.Format(@"~\temp\{0}_{1:HHmmss}_{1:ffff}.{2}", name, DateTime.Now, fileNameExtension);
        Stream stream = new FileStream(SteamWare.SteamwareStrings.getFilePath(filePathName), FileMode.Create);
        m_streams.Add(stream);
        return stream;
    }
    /// <summary>
    /// ciclo da fornire al renderizzatore dei report, per salvare 1 pdf da ogni pagina del report
    /// </summary>
    /// <param name="name"></param>
    /// <param name="fileNameExtension"></param>
    /// <param name="encoding"></param>
    /// <param name="mimeType"></param>
    /// <param name="willSeek"></param>
    /// <returns></returns>
    private Stream CreateStreamPdf(string name, string fileNameExtension, Encoding encoding, string mimeType, bool willSeek)
    {
        // creo Directory se non c'è
        SteamWare.fileMover fm = new fileMover(string.Format(@"{0}\{1:yyyy}\{1:MM}\{1:dd}\", memLayer.ML.confReadString("PdfFolder"), DateTime.Now), "");
        fm.checkDir();
        string pdfPathName = string.Format(@"{0}\{1:yyyy}\{1:MM}\{1:dd}\{2}_{1:HHmmss}_{1:ffff}.{3}", memLayer.ML.confReadString("PdfFolder"), DateTime.Now, name, fileNameExtension);
        Stream stream = new FileStream(SteamWare.SteamwareStrings.getFilePath(pdfPathName), FileMode.Create);
        m_streams.Add(stream);
        return stream;
    }
    /// <summary>
    /// Handler per PrintPageEvents
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="ev"></param>
    private void PrintPage(object sender, PrintPageEventArgs ev)
    {
        Metafile pageImage = new Metafile(m_streams[m_currentPageIndex]);
        ev.Graphics.DrawImage(pageImage, ev.PageBounds);
        m_currentPageIndex++;
        ev.HasMorePages = (m_currentPageIndex < m_streams.Count);
    }
    /// <summary>
    /// funzione di stampa...
    /// </summary>
    private void Print(string printerName)
    {
        //const string printerName = "Microsoft Office Document Image Writer";
        //const string printerName = "Brother HL-2170W series";
        if (m_streams == null || m_streams.Count == 0)
            return;
        PrintDocument printDoc = new PrintDocument();
        printDoc.PrinterSettings.PrinterName = printerName;
        if (!printDoc.PrinterSettings.IsValid)
        {
            logger.lg.scriviLog(String.Format("Impostazioni non valide per la stampante \"{0}\".", printerName), tipoLog.ERROR);
            return;
        }
        printDoc.PrintPage += new PrintPageEventHandler(PrintPage);
        printDoc.Print();
    }
    /// <summary>
    /// Export del report come EMF (Enhanced Metafile) file.
    /// </summary>
    /// <param name="report"></param>
    private void Export(LocalReport report, string deviceInfo)
    {
        Warning[] warnings;
        m_streams = new List<Stream>();
        report.Render("Image", deviceInfo, CreateStream, out warnings);
        foreach (Stream stream in m_streams) stream.Position = 0;
    }
    /// <summary>
    /// Export del report come PDF file.
    /// </summary>
    /// <param name="report"></param>
    private void ExportPDF(LocalReport report, string deviceInfo)
    {
        Warning[] warnings;
        m_streams = new List<Stream>();
        report.Render("PDF", deviceInfo, CreateStreamPdf, out warnings);
        foreach (Stream stream in m_streams) stream.Position = 0;
    }
    /// <summary>
    /// dispone l'applicazione e rilascia le risorse
    /// </summary>
    public void Dispose()
    {
        if (m_streams != null)
        {
            foreach (Stream stream in m_streams)
                stream.Close();
            m_streams = null;
        }
    }

    #endregion

    #region area codice da modificare

    /// <summary>
    /// carica i dati richiesti dal report dalla StoredProcedure (filtrando quindi...)
    /// </summary>
    /// <param name="tipoReport"></param>
    /// <param name="UDC">cod UDC</param>
    /// <returns>tabella dati</returns>
    private DataTable caricaDati(reportRichiesto tipoReport, int ticket)
    {
        DataTable tab = new DataTable();
        switch (tipoReport)
        {
            case reportRichiesto.ReportOffers:
                tab = (DataTable)DtProxy.man.taPQuot.GetData(ticket, "");
                break;
            //case reportRichiesto.ReportSimulation:
            //    tab = (DataTable)DtProxy.man.taQFQ.repOffersByTicket(ticket);
            //    break; 
            case reportRichiesto.Vocabolario:
                tab = (DataTable)SteamWare.selDataVoc.mgr.getVocabolarioByLemma(SteamWare.user_std.UtSn.lingua, "C2P_prt1");
                break;
            default:
                break;
        }
        return tab;
    }
    /// <summary>
    /// Crea un report locale da file rdlc, carica i dati, esporta report come EMF file e quindi lo invia alla stampante
    /// </summary>
    /// <param name="tipoReport">report ammessi: ElencoMacchine / RichiestaIntervento</param>
    /// <param name="printerName">nome completo stampante (rispetto al server)</param>
    /// <param name="UDC">cod UDC</param>
    /// <param name="deviceInfoParam">parametri "device input"</param>
    public void printReport(reportRichiesto tipoReport, string printerName, int ticket, devInfoParam deviceInfoParam)
    {
        LocalReport report = new LocalReport();
        report.EnableExternalImages = true;
        string deviceInfo = "";
        switch (tipoReport)
        {
            case reportRichiesto.ReportOffers:
                report.ReportPath = System.Web.HttpContext.Current.Server.MapPath(@".\Reports\ReportOffers.rdlc");
                // 2) caricamento tab dati
                DataTable tabVoc = new DataTable();
                DataTable tabQuote = new DataTable();
                tabVoc = (DataTable)SteamWare.selDataVoc.mgr.getVocabolarioByLemma(SteamWare.user_std.UtSn.lingua, "C2P_prt1");
                tabQuote = (DataTable)DtProxy.man.taPQuot.GetData(ticket, "");
                // 3) inserimento dataset nel report
                report.DataSources.Add(new ReportDataSource("dsVocabolario", tabVoc));
                report.DataSources.Add(new ReportDataSource("dsQuoteFull_Q_Data", tabQuote));

                //report.DataSources.Add(new ReportDataSource("dsQuoteFull_Q_Data", caricaDati(tipoReport, ticket)));
                //report.DataSources.Add(new ReportDataSource("dsVocabolario", caricaDati(reportRichiesto.Vocabolario, ticket)));
                break;
            //case reportRichiesto.ReportSimulation:
            //    report.ReportPath = @".\Reports\ReportSimulation.rdlc";
            //    report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("RepDsSimulation"), caricaDati(tipoReport, ticket)));
            //    break;
        }
        deviceInfo = deviceInfoParam.xmlParam;
        doEmfPrint(printerName, report, deviceInfo);
        // controllo se devo fare copia PDF... stampiamo ANCHE su pdf su una folder locale
        if (doPdfCopy)
        {
            deviceInfoParam.OutputFormat = "PDF";
            deviceInfo = deviceInfoParam.xmlParam;
            doLocalPdfPrint(report, deviceInfo);
        }
    }
    /// <summary>
    /// esegue print vero e proprio
    /// </summary>
    /// <param name="printerName"></param>
    /// <param name="report"></param>
    /// <param name="deviceInfo"></param>
    private void doEmfPrint(string printerName, LocalReport report, string deviceInfo)
    {
        // export in EMF
        Export(report, deviceInfo);
        m_currentPageIndex = 0;
        // stampo
        Print(printerName);
        // do dispose?
        Dispose();
    }
    /// <summary>
    /// effettua stampa in PDF dei vari report in una cartella Anno/Mese/Giorno
    /// </summary>
    /// <param name="report"></param>
    /// <param name="deviceInfo"></param>
    private void doLocalPdfPrint(LocalReport report, string deviceInfo)
    {
        // export in PDF
        ExportPDF(report, deviceInfo);
        m_currentPageIndex = 0;
        // do dispose?
        Dispose();
    }
    /// <summary>
    /// effettua la stampa del cartellino indicato
    /// </summary>
    /// <param name="tipoReport"></param>
    /// <param name="ticket"></param>
    /// <param name="printerName">indirizzo di rete completo stampante del tipo \\nomePc\nomeStampante, oppure "" x default</param>
    /// <returns></returns>
    public bool stampaReport(reportRichiesto tipoReport, int ticket, string printerName)
    {
        bool answ = false;
        int idxPrintJob = 0;
        // gestione coda: SE abilitata...
        if (memLayer.ML.confReadBool("enableQueue"))
        {
            // disabilitata COMUNQUE coda (per ora)
#if false
            // incomincio con gestione della coda di stampa... inserisco in tab la richiesta di stampa...
            DataProxy.obj.taPJQ.insertQuery(tipoReport.ToString(), UDC, printerName);
            // faccio un ciclo while... finchè non sono "in testa" alla coda delle esecuzioni aspetto...
            string nextUdc = "ND";
            try
            {
                nextUdc = DataProxy.obj.taPJQ.getNext()[0].UDC;
            }
            catch
            {
                nextUdc = "ND";
            }
            // verifico eventuali processi zombie: quelli in stato 0 con LastTry superiore a data attuale meno zombieMsTime
            DataProxy.obj.taPJQ.chiudiZoombie(DateTime.Now.AddMilliseconds(-memLayer.ML.confReadInt("zombieMsTime")));
            // ora inizio a fare le mie stampe...
            Random rand = new Random();
            int msWait = 200;
            while (nextUdc != UDC)
            {
                // indico che ho fatto un tentativo di stampa aggiornando dtLastTry
                DataProxy.obj.taPJQ.updateLastTry(UDC);
                // aspetto...
                msWait = rand.Next(memLayer.ML.confReadInt("minWait"), memLayer.ML.confReadInt("maxWait"));
                System.Threading.Thread.Sleep(msWait);
                // leggo prox record da coda
                nextUdc = DataProxy.obj.taPJQ.getNext()[0].UDC;
            }
            // salvo idx job...
            idxPrintJob = DataProxy.obj.taPJQ.getNext()[0].IdxPrintJob;
#endif
        }
        string outForm = "";
        string pagWidth = "";
        string pagHeigth = "";
        string margin = "";
        string tipo = "";
        switch (tipoReport)
        {
            case reportRichiesto.ReportOffers:
                tipo = "Offers";
                break;
            //case reportRichiesto.ReportOffers:
            //    tipo = "Offers";
            //    break;
            default:
                break;
        }
        // carico di dati con lettura da web.config parametrica
        if (printerName == "")
        {
            printerName = memLayer.ML.confReadString(string.Format("printer{0}", tipo));
        }
        outForm = "EMF";
        pagWidth = memLayer.ML.confReadString(string.Format("PageWidth{0}", tipo));
        pagHeigth = memLayer.ML.confReadString(string.Format("PageHeight{0}", tipo));
        margin = memLayer.ML.confReadString(string.Format("Margin{0}", tipo));
        // compongo parametri stampa
        devInfoParam deviceInfo = new devInfoParam(outForm, pagHeigth, pagWidth, margin, margin, margin, margin);
        answ = printAndLog(ticket, printerName, answ, tipoReport, deviceInfo);
        // gestione coda: SE abilitata...
        if (memLayer.ML.confReadBool("enableQueue"))
        {
            // disabilitata COMUNQUE coda (per ora)
#if false
                    if (answ)
            {
                // registro stampato in tabella queue...
                DataProxy.obj.taPJQ.updateStato(idxPrintJob, 1);
            }
            else
            {
                // registro annullato in tab queue...
                DataProxy.obj.taPJQ.updateStato(idxPrintJob, -1);
            }
#endif
        }
        return answ;
    }
    /// <summary>
    /// effettua la vera e propria fase di stampa
    /// </summary>
    /// <param name="ticket"></param>
    /// <param name="printerName"></param>
    /// <param name="answ"></param>
    /// <param name="report"></param>
    /// <param name="deviceInfo"></param>
    /// <returns></returns>
    private bool printAndLog(int ticket, string printerName, bool answ, reportRichiesto report, devInfoParam deviceInfo)
    {
        try
        {
            if (logLevel > 5) logger.lg.scriviLog(String.Format("Sto per inviare un report alla stampante {0}", printerName), tipoLog.INFO);
            reportPrinter.obj.printReport(report, printerName, ticket, deviceInfo);
            if (logLevel > 5) logger.lg.scriviLog(String.Format("inviato comando print alla stampante {0}", printerName), tipoLog.INFO);
            answ = true;
        }
        catch (Exception e)
        {
            logger.lg.scriviLog(String.Format("Errore in fase di creazione e stampa report: stampante {0}, errore riscontrato {1}", printerName, e), tipoLog.EXCEPTION);
        }
        return answ;
    }
    /// <summary>
    /// oggetto protected
    /// </summary>
    /// <param name="args"></param>
    protected reportPrinter()
    {
        logLevel = memLayer.ML.confReadInt("_logLevel");
        doPdfCopy = memLayer.ML.confReadBool("doPdfCopy");
    }
    /// <summary>
    /// singleton pubblico
    /// </summary>
    public static reportPrinter obj = new reportPrinter();
    /// <summary>
    /// effettua pulizia della cartella temp x i files più vecchi di X ore (web.config)
    /// </summary>
    public void pulisciDir()
    {
        // num max ore di età x files "vecchi" da tenere in temp area...
        int maxOre = memLayer.ML.confReadInt("maxAgeTempAreaHours");
        int eliminati = 0;
        // ottengo elenco files *.emf
        fileMover.obj.setDirectory(@"~\temp\");
        FileInfo[] _fis = fileMover.obj.elencoFiles_FI("*.emf");
        bool fatto = false;
        foreach (FileInfo _file in _fis)
        {
            if (_file.CreationTime < DateTime.Now.AddHours(-maxOre)) // elimino files vecchi...
            {
                fatto = fileMover.obj.eliminaFile(_file);
                if (fatto)
                {
                    logger.lg.scriviLog(String.Format("Eliminato file {0}", _file.Name), tipoLog.INFO);
                    eliminati++;
                }
            }
        }
        // salvo il log degli update
        if (eliminati > 0)
        {
            logger.lg.scriviLog(String.Format("Eliminati {0} files temporanei da area temp", eliminati), tipoLog.INFO);
        }
    }

    #endregion
}
/// <summary>
/// tipologia di report ammessi alla stampa...
/// </summary>
public enum reportRichiesto
{
    ReportOffers
        //, ReportSimulation
    , Vocabolario
}