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 GMW_data;

/// <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)
    {
        Stream stream = new FileStream(SteamWare.SteamwareStrings.getFilePath(@"~\temp\" + name + "." + fileNameExtension), 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(@"~\temp\" + name + "." + fileNameExtension), FileMode.Create);
        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("Can't find printer \"{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, string UDC)
    {
        DataTable tab = new DataTable();
        switch (tipoReport)
        {
            case reportRichiesto.CartellinoAnime:
                tab = (DataTable)GMW_data.DataProxy.obj.taPrtCartAnime.GetData(UDC);
                break;
            case reportRichiesto.CartellinoFin:
                tab = (DataTable)GMW_data.DataProxy.obj.taPrtCart.GetData(UDC);
                break;
            case reportRichiesto.CartellinoFusi:
                tab = (DataTable)GMW_data.DataProxy.obj.taPrtCart.GetData(UDC);
                break;
            case reportRichiesto.CartellinoLiquidiF10:
                tab = (DataTable)GMW_data.DataProxy.obj.taPrtCartLiqF10.GetData(UDC);
                break;
            case reportRichiesto.CartellinoLiquidiF18:
                tab = (DataTable)GMW_data.DataProxy.obj.taPrtCartLiqF18.GetData(UDC);
                break;
            case reportRichiesto.CartellinoMP:
                tab = (DataTable)GMW_data.DataProxy.obj.taPrtCartMP.GetData(UDC);
                break;
            case reportRichiesto.CartellinoOdette:
                tab = (DataTable)GMW_data.Odette.mgr.taOdette.getByUdc(UDC);
                break;
            case reportRichiesto.CartellinoTara:
                tab = (DataTable)GMW_data.DataProxy.obj.taPrtCart.GetData(UDC);
                break;
            case reportRichiesto.CartellinoWIP:
                tab = (DataTable)GMW_data.DataProxy.obj.taPrtCart.GetData(UDC);
                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, string UDC, devInfoParam deviceInfoParam)
    {
        LocalReport report = new LocalReport();
        string deviceInfo = "";
        switch (tipoReport)
        {
            case reportRichiesto.CartellinoAnime:
                report.ReportPath = @".\Reports\CartellinoAnime.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasourceAnime"), caricaDati(tipoReport, UDC)));
                break;
            case reportRichiesto.CartellinoFin:
                report.ReportPath = @".\Reports\CartellinoFinito.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasource"), caricaDati(tipoReport, UDC)));
                break;
            case reportRichiesto.CartellinoFusi:
                report.ReportPath = @".\Reports\CartellinoFus.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasource"), caricaDati(tipoReport, UDC)));
                break;
            case reportRichiesto.CartellinoMP:
                report.ReportPath = @".\Reports\CartellinoMP.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasource"), caricaDati(tipoReport, UDC)));
                break;
            case reportRichiesto.CartellinoLiquidiF10:
                report.ReportPath = @".\Reports\CartellinoLiquidiF10.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasourceLiquidiF10"), caricaDati(tipoReport, UDC)));
                break;
            case reportRichiesto.CartellinoLiquidiF18:
                report.ReportPath = @".\Reports\CartellinoLiquidiF18.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasourceLiquidiF18"), caricaDati(tipoReport, UDC)));
                break;
            case reportRichiesto.CartellinoOdette:
                report.ReportPath = @".\Reports\CartellinoOdette.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasourceOdette"), caricaDati(tipoReport, UDC)));
                break;
            case reportRichiesto.CartellinoTara:
                report.ReportPath = @".\Reports\CartellinoTara.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasource"), caricaDati(tipoReport, UDC)));
                break;
            case reportRichiesto.CartellinoWIP:
                report.ReportPath = @".\Reports\CartellinoWip.rdlc";
                report.DataSources.Add(new ReportDataSource(memLayer.ML.confReadString("ReportDatasource"), caricaDati(tipoReport, UDC)));
                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="cartellino"></param>
    /// <param name="UDC"></param>
    /// <param name="printerName">indirizzo di rete completo stampante del tipo \\nomePc\nomeStampante, oppure "" x default</param>
    /// <returns></returns>
    public bool stampaCartellino(tipoCartellino cartellino, string UDC, string printerName)
    {
        bool answ = false;
        string outForm = "";
        string pagWidth = "";
        string pagHeigth = "";
        string margin = "";
        reportRichiesto report = reportRichiesto.CartellinoFusi;
        string tipo = "";
        switch (cartellino)
        {
            case tipoCartellino.cartAnime:
                tipo = "CartAnime";
                report = reportRichiesto.CartellinoAnime;
                break;
            case tipoCartellino.cartFin:
                tipo = "CartFin";
                report = reportRichiesto.CartellinoFin;
                break;
            case tipoCartellino.cartFusi:
                tipo = "CartFusi";
                report = reportRichiesto.CartellinoFusi;
                break;
            case tipoCartellino.cartLiquidiF10:
                tipo = "CartLiquidiF10";
                report = reportRichiesto.CartellinoLiquidiF10;
                break;
            case tipoCartellino.cartLiquidiF18:
                tipo = "CartLiquidiF18";
                report = reportRichiesto.CartellinoLiquidiF18;
                break;
            case tipoCartellino.cartMP:
                tipo = "CartMP";
                report = reportRichiesto.CartellinoMP;
                break;
            case tipoCartellino.cartOdette:
                tipo = "CartOdette";
                report = reportRichiesto.CartellinoOdette;
                break;
            case tipoCartellino.cartTara:
                tipo = "CartTara";
                report = reportRichiesto.CartellinoTara;
                break;
            case tipoCartellino.cartWip:
                tipo = "CartWip";
                report = reportRichiesto.CartellinoWIP;
                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(UDC, printerName, answ, report, deviceInfo);
        return answ;
    }
    /// <summary>
    /// effettua la vera e propria fase di stampa
    /// </summary>
    /// <param name="UDC"></param>
    /// <param name="printerName"></param>
    /// <param name="answ"></param>
    /// <param name="report"></param>
    /// <param name="deviceInfo"></param>
    /// <returns></returns>
    private bool printAndLog(string UDC, 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, UDC, 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();

    #endregion
}
/// <summary>
/// tipologia di report ammessi alla stampa...
/// </summary>
public enum reportRichiesto
{
    CartellinoAnime,
    CartellinoFin,
    CartellinoFusi,
    CartellinoLiquidiF10,
    CartellinoLiquidiF18,
    CartellinoMP,
    CartellinoOdette,
    CartellinoTara,
    CartellinoWIP
}