//...
using RootNameSpaceDaAdattare.Libraries.IO.Csv;
//...
namespace RootNameSpaceDaAdattare.Libraries.IO
{
    public class FileHelper
    {    		
        #region CSV, FIXED length I\O
		//quel che è qui lo riporto nel codice\metodo che è nella sezione successiva
        #endregion

#region CSV, FIXED length I\O
 
/// <summary>
/// Dato un file CSV ne restituisce il DataTable i cui campi\colonne sono quelli CSV ovvero separati da un carattere nel file.
/// </summary>
/// <param name="fileFullPath">Percorso fisico del file comprensivo di nome file</param>
/// <param name="strFileEncoding">Encoding col quale LEGGERE il file su FileSystem, se NULL lo determina automaticamente. Valori previsti per System.Text.Encoding</param>
/// <param name="hasHeaders">Se ha o meno una intestazione</param>
/// <param name="delimiter">Carattere delimitatore che separa ciascun campo</param>
/// <param name="quote4EveryField">Carattere contenitore di ogni campo (NON confondere col separatore di campo), SE NON PREVISTO PASSARE ' ' oppure null
/// E' FONDAMENTALE, altrimenti l'algoritmo potrebbe fallire in casi limite. Se non si usa TIPIZZAZIONE dei campi PASSARE NULL</param>
/// <param name="skipFirstNRow">Primi N righi da saltare eventualmente</param>
/// <param name="maxRecords">Numero massimo di righi entro cui restituire l'output</param>
/// <param name="showRowNumber">Se mostrare il numero di riga accanto a ciascun record come se fosse un campo previsto in prima colonna</param>
/// <returns></returns>
public static DataTable GetDataTableFromCSV(string fileFullPath, string strFileEncoding, bool hasHeaders, char delimiter, char? quote4EveryField,
	int skipFirstNRow, int maxRecords, bool showRowNumber)
{   
	if (!File.Exists(fileFullPath))
	{
		throw new Exception(String.Format("Non trovato il file da elaborare '{0}'.", fileFullPath));
	}
	string strRunningLOG = string.Empty;
	string fileName = Path.GetFileName(fileFullPath);
	int recordIndex = 0;
	int fieldCount = 0;
	DataTable dt = new DataTable(fileName);
	Encoding encodingFileInput = GetEncodingCodeFromString(strFileEncoding, fileFullPath);
 
	//Si crea eventuale colonna del progressivo (utile in fase di TEST per definire il dataTable con le info)
	if (showRowNumber)
	{
		dt.Columns.Add("Nr", typeof(string));
	}
 
	//Verifica inconsistenze
	if (hasHeaders)
	{
		string strLOG = string.Empty;
		HeaderWithDuplicate(fileFullPath, skipFirstNRow, delimiter, ref strLOG);
		strRunningLOG += strLOG;
	}
	int currFieldIndex = 0;
 
	try
	{
		//Carattere contenitore di ogni campo (NON confondere col separatore di campo)
		//Prima il DEfault era il " ovvero: quote = '"';
		char quote = (quote4EveryField == null || quote4EveryField == ' ') ?
					(char)0 : quote4EveryField.Value;     //'"';
		using (CsvReader csv = new CsvReader(new StreamReader(fileFullPath, encodingFileInput), hasHeaders, delimiter, quote))
		{
			csv.DefaultHeaderName = "X";
			fieldCount = csv.FieldCount; //Fa scattare la lettura del BUFFER !!!
			//Vettore di intestazione
			string[] headers = csv.GetFieldHeaders();
			if (headers.Length == 0)
			{
				headers = new string[fieldCount];
				for (int i = 0; i < fieldCount; i++)
				{
					headers[i] = "C" + (i +1);
				}
			}
 
			string columnName = string.Empty;
			for (int i = 0; i < fieldCount; i++)
			{
				columnName = headers[i];
				dt.Columns.Add(columnName, typeof(string));
			}
 
			//Eventuale salto delle prime n righe
			if (skipFirstNRow > 0)
			{
				while (csv.ReadNextRecord() && skipFirstNRow > 0)
				{
					skipFirstNRow--;
				}
			}
			//-----------------------------------------------------------
			//          Lettura + Scrittura delle Righe\Records!
			//-----------------------------------------------------------
			fieldCount = showRowNumber ? fieldCount + 1 : fieldCount;
			//Si cicla sull'oggetto CSV [ogni ReadNextRecord fa AVANZARE sul rigo successivo] per ciascun rigo ovvero 
			//per ciascun record, ogniuno di questo verrà aggiunto al dataTable ciclando ancora per ciascun valore\campo della colonna
 
			while (csv.ReadNextRecord() 
				&& (maxRecords  == 0 || recordIndex < maxRecords))
			{
				recordIndex++;
				DataRow dr = dt.NewRow();
				currFieldIndex = 0;
				//Per ogni colonna
				for (int i = 0; i < fieldCount; i++)
				{
					if (showRowNumber && i == 0)
					{
						dr[i] = recordIndex;
						currFieldIndex--;
					}
					else
					{
						dr[i] = csv[currFieldIndex];
					}
					if (csv.TranformationPatchDone) //Se è stato necessario porre delle pezze con caratteri di transizione
					{
						dr[i] = csv.RestoreFieldPatched(dr[i].ToString());
					}
					currFieldIndex++;
				}
				dt.Rows.Add(dr);
			}
		}
	}
	catch (Exception ex)
	{
		//ATTENZIONE non ha attendibilità certificata la info: recordIndex + 1. Dall'ultimo test sembra veritiero ovvero:
		//  recordIndex + 1   è il rigo del file dov'è l'errore
		string strError = String.Format("Errore in [GetDataTableFromCSV] record {0}, campo nr {1}.\r\n{2}", 
			recordIndex + 1, currFieldIndex, ex.Message + "\r\n\r\n" + ex.StackTrace);
		throw new Exception(strError);
	}
	return dt;
}
#endregion

        /// <summary>
        /// Determina l'encoding del file di cui fornisco il Path. E' un tentetivo ma non è detto che funzionio, studia documentazione.
        /// </summary>
        /// <param name="fileFullPath"></param>
        /// <returns></returns>
        public static Encoding TryDetectFileEncoding(string fileFullPath)
        {
            #region DOCUMENTATION 
            /*
                You can't depend on the file having a BOM. UTF-8 doesn't require it. And non-Unicode encodings don't even have a BOM. 
                There are, however, other ways to detect the encoding.
 
                UTF-32
                BOM is 00 00 FE FF (for BE) or FF FE 00 00 (for LE).
                But UTF-32 is easy to detect even without a BOM. This is because the Unicode code point range is restricted to U+10FFFF, 
                and thus UTF-32 units always have the pattern 00 {0x|10} xx xx (for BE) or xx xx {0x|10} 00 (for LE). If the data has a
                length that's a multiple of 4, and follows one of these patterns, you can safely assume it's UTF-32. 
                False positives are nearly impossible due to the rarity of 00 bytes in byte-oriented encodings.
 
                US-ASCII
                No BOM, but you don't need one. ASCII can be easily identified by the lack of bytes in the 80-FF range.
 
                UTF-8
                BOM is EF BB BF. But you can't rely on this. Lots of UTF-8 files don't have a BOM, especially if they originated
                on non-Windows systems.
                But you can safely assume that if a file validates as UTF-8, it is UTF-8. False positives are rare.
                Specifically, given that the data is not ASCII, the false positive rate for a 2-byte sequence is only 3.9% (1920/49152). 
                For a 7-byte sequence, it's less than 1%. For a 12-byte sequence, it's less than 0.1%. For a 24-byte sequence, 
                it's less than 1 in a million.
 
                UTF-16
                BOM is FE FF (for BE) or FF FE (for LE). Note that the UTF-16LE BOM is found at the start of the UTF-32LE BOM, 
                so check UTF-32 first.
                There may be UTF-16 files without a BOM, but it would be really hard to detect them. The only reliable way to 
                recognize UTF-16 without a BOM is to look for surrogate pairs (D[8-B]xx D[C-F]xx), but non-BMP characters are too 
                rarely-used to make this approach practical.
 
                XML
                If your file starts with the bytes 3C 3F 78 6D 6C (i.e., the ASCII characters "<?xml"), then look for an 
                encoding=declaration. If present, then use that encoding. If absent, then assume UTF-8, which is the default XML encoding.
                If you need to support EBCDIC, also look for the equivalent sequence 4C 6F A7 94 93.
 
                In general, if you have a file format that contains an encoding declaration, then look for that declaration rather than 
                trying to guess the encoding.
             */
            #endregion
            // *** Use Default of Encoding.Default (Ansi CodePage)
            Encoding enc = Encoding.Default;
 
            // *** Detect byte order mark if any - otherwise assume default
            byte[] buffer = new byte[5];
            FileStream file = new FileStream(fileFullPath, FileMode.Open);
            file.Read(buffer, 0, 5);
            file.Close();
 
            if (buffer[0] == 0xef && buffer[1] == 0xbb && buffer[2] == 0xbf)
            {
                enc = Encoding.UTF8;
            }
            else if (buffer[0] == 0xfe && buffer[1] == 0xff)
            {
                enc = Encoding.Unicode;
            }
            else if (buffer[0] == 0 && buffer[1] == 0 && buffer[2] == 0xfe && buffer[3] == 0xff
                || buffer[0] == 0xFF && buffer[1] == 0xFE && buffer[2] == 0 && buffer[3] == 0)
            {
                enc = Encoding.UTF32;
            }
            else if (buffer[0] == 0x2b && buffer[1] == 0x2f && buffer[2] == 0x76)
            {
                enc = Encoding.UTF7;
            }
            else if (buffer[0] == 0xFE && buffer[1] == 0xFF)
                // 1201 unicodeFFFE Unicode (Big-Endian)
            {
                enc = Encoding.GetEncoding(1201);
            }
            else if (buffer[0] == 0xFF && buffer[1] == 0xFE ||
                buffer[0] == 0xFE && buffer[1] == 0xFF)
            // 1200 utf-16 Unicode
            {
                enc = Encoding.GetEncoding(1200); 
            }
            return enc;
        }
        #endregion
 
        #region Private METHODS
        private static Encoding GetEncodingCodeFromString(string strEncoding, string fileFullPath)
        {
            Encoding encodingCalc = Encoding.Default;
            if (string.IsNullOrEmpty(strEncoding))
            {
                encodingCalc = TryDetectFileEncoding(fileFullPath);
            }
            else
            {
                switch (strEncoding)
                {
                    case "ASCII":
                        encodingCalc = Encoding.ASCII;
                        break;
                    case "BigEndianUnicode":
                        encodingCalc = Encoding.BigEndianUnicode;
                        break;
                    case "Default":
                        encodingCalc = Encoding.Default;
                        break;
                    case "Unicode":
                        encodingCalc = Encoding.Unicode;
                        break;
                    case "UTF32":
                        encodingCalc = Encoding.UTF32;
                        break;
                    case "UTF7":
                        encodingCalc = Encoding.UTF7;
                        break;
                    case "UTF8":
                        encodingCalc = Encoding.UTF8;
                        break;
                }
            }
            return encodingCalc;
        }
 
        private static string PrintDr(DataRow dr)
        {
            string strOutput = string.Empty;
            int nrDataColumn = dr.Table.Columns.Count;
 
            for (int i = 0; i < nrDataColumn; i++)
            {
                strOutput += "'" + dr[i] + "'\t";
            }
            return strOutput + "\r\n";
        }
 
        private static bool HeaderWithDuplicate(string fileFullPath, int skipFirstNRow, char delimiter, ref string strLOG)
        { 
            string lineHeader;
 
            try
            {
                StreamReader sr = new StreamReader(fileFullPath);
                lineHeader = sr.ReadLine();
                if (skipFirstNRow > 0)
                {
                    skipFirstNRow--;
                    while (lineHeader != null && skipFirstNRow > 0)
                    {
                        lineHeader = sr.ReadLine();
                    }
                }
                sr.Close();
                //Ho la riga di intestazione!!!
                string[] columns = lineHeader.Split(delimiter);
                if (columns.Length > 0)
                {
                    string stringToFind = string.Empty;
                    for (int j = 0; j < columns.Length; j++)
                    {
                        stringToFind = columns[j];
                        for (int i = j + 1; i < columns.Length; i++)
                        {
                            if (columns[i].IndexOf(stringToFind) >= 0)
                            {
                                strLOG += string.IsNullOrEmpty(strLOG) ? "Intestazione con colonne duplicate:\r\n" : string.Empty;
                                strLOG += stringToFind + "\r\n";
                                break; 
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                strLOG += "\r\n[HeaderWithDuplicate] Exception: " + e.Message;
            }
            return !string.IsNullOrEmpty(strLOG);
        }
 
        /// <summary>
        /// Verifica se per il rigo\DataRow corrente c'è un campo contente l'informazione da riportare ai righi successivi. 
        /// Il contenuto di questo campo puntato andrà in corrispondenza del campo\Coloumn vuoto nel gruppo di info di prodotto successive)
        /// </summary>
        /// <param name="currentDr"></param>
        /// <returns>Se il rigo corrente contiene il campo cercato restituisce la posizione dello stesso altrimenti -1 !</returns>
        private static int IsThereFieldToRepeat(DataRow currentDr, int nColumn)
        {
            int maxToQualifyFieldToRepeat = 1;
            int idxCurrent = -1;
            int nrNotEmpty = 0;
 
            for (int j = 0; j < nColumn; j++)
            {
                //Si fa una IMPORTANTE IPOTESI ovvero che i campi ripetuti siano testuali !!!!!!!!!!!!!!!!!!!!!!!
                if (currentDr[j] != DBNull.Value
                    && currentDr[j].ToString() != string.Empty)
                {
                    idxCurrent = j;
                    nrNotEmpty++;
                }
                if (nrNotEmpty > maxToQualifyFieldToRepeat)
                {
                    break;
                }
            }
 
            if (nrNotEmpty == 0)
            {
                return -2; //Codice per far escludere il rigo corrente in quanto totalmente vuoto!
            }
            // Funziona solo per:   maxToQualifyFieldToRepeat == 1            
            return (nrNotEmpty == maxToQualifyFieldToRepeat) ? idxCurrent : -1;
        }
        #endregion

 public static void DatatableToCsv(System.Web.HttpResponse response,  DataTable dt, string fileName, string delimiter)
{
	response.Clear();
	response.ContentType = "text/csv";
	response.AppendHeader("Content-Disposition",
		string.Format("attachment; filename={0}", fileName));
 
	for (int i = 0; i < dt.Columns.Count; i++)
	{
		response.Write(dt.Columns[i].ColumnName);
		response.Write((i < dt.Columns.Count - 1) ? delimiter : Environment.NewLine);
	}
 
	foreach (DataRow row in dt.Rows)
	{
		for (int i = 0; i < dt.Columns.Count; i++)
		{
			response.Write(row[i].ToString());
			response.Write((i < dt.Columns.Count - 1) ? delimiter : Environment.NewLine);
		}
	}
	response.End();
}