using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;

namespace Kreta.BusinessLogic.Classes.ExcelHelpers
{
    public static class OpenXmlExcelUtils
    {
        #region Tulajdonságok
        public const string ExcelVersion = "0.1";
        const string VersionNumberReference = "ZZ1";

        public static string GetExcelColumnName(int columnNumber)
        {
            int dividend = columnNumber + 1;
            string columnName = string.Empty;
            int modulo;

            while (dividend > 0)
            {
                modulo = (dividend - 1) % 26;
                columnName = Convert.ToChar(65 + modulo).ToString() + columnName;
                dividend = (int)((dividend - modulo) / 26);
            }
            return columnName;
        }

        #endregion

        #region GetColumnNameIndex
        public static int GetColumnNameIndex(string column)
        {
            int retVal = 0;
            string col = column.ToUpper();
            for (int iChar = col.Length - 1; iChar >= 0; iChar--)
            {
                char colPiece = col[iChar];
                int colNum = colPiece - 64;
                retVal += colNum * (int)Math.Pow(26, col.Length - (iChar + 1));
            }
            return retVal;
        }

        #endregion

        #region GetColumnIndex
        public static int GetColumnIndex(string reference)
        {
            int ci = 0;
            reference = reference.ToUpper();
            for (int ix = 0; ix < reference.Length && reference[ix] >= 'A'; ix++)
            {
                ci = (ci * 26) + ((int)reference[ix] - 64);
            }

            return ci;
        }
        #endregion

        #region create cell in worksheet
        // Given a column name, a row index, and a WorksheetPart, inserts a cell into the worksheet.
        // If the cell already exists, returns it.
        // Given a Worksheet and a cell name, verifies that the specified cell exists.
        // If it does not exist, creates a new cell.
        public static Cell CreateSpreadsheetCellIfNotExist(Worksheet worksheet, string cellName)
        {
            string columnName = GetColumnName(cellName);
            uint rowIndex = GetRowIndex(cellName);

            Cell cell = new Cell();
            IEnumerable<Row> rows = worksheet.Descendants<Row>().Where(r => r.RowIndex.Value == rowIndex);

            // If the Worksheet does not contain the specified row, create the specified row.
            // Create the specified cell in that row, and insert the row into the Worksheet.
            if (!rows.Any())
            {
                Row row = new Row() { RowIndex = new UInt32Value(rowIndex) };
                cell = new Cell() { CellReference = new StringValue(cellName) };
                row.Append(cell);
                worksheet.Descendants<SheetData>().First().Append(row);

            }
            else
            {
                Row row = rows.First();

                IEnumerable<Cell> cells = row.Elements<Cell>().Where(c => c.CellReference.Value == cellName);

                // If the row does not contain the specified cell, create the specified cell.
                if (!cells.Any())
                {
                    cell = new Cell() { CellReference = new StringValue(cellName) };
                    row.Append(cell);

                }
            }

            return cell;

        }
        #endregion

        #region InsertSharedStringItem
        // Given text and a SharedStringTablePart, creates a SharedStringItem with the specified text
        // and inserts it into the SharedStringTablePart. If the item already exists, returns its index.
        public static int InsertSharedStringItem(string text, SharedStringTablePart shareStringPart)
        {
            // If the part does not contain a SharedStringTable, create one.
            if (shareStringPart.SharedStringTable == null)
            {
                shareStringPart.SharedStringTable = new SharedStringTable();
            }

            int i = 0;

            // Iterate through all the items in the SharedStringTable. If the text already exists, return its index.
            foreach (SharedStringItem item in shareStringPart.SharedStringTable.Elements<SharedStringItem>())
            {
                if (item.InnerText == text)
                {
                    return i;
                }

                i++;
            }

            // The text does not exist in the part. Create the SharedStringItem and return its index.
            shareStringPart.SharedStringTable.AppendChild(new SharedStringItem(new DocumentFormat.OpenXml.Spreadsheet.Text(text)));
            shareStringPart.SharedStringTable.Save();

            return i;
        }
        #endregion

        #region GetColumnName
        // Given a cell name, parses the specified cell to get the column name.
        public static string GetColumnName(string cellName)
        {
            // Create a regular expression to match the column name portion of the cell name.
            Regex regex = new Regex("[A-Za-z]+");
            Match match = regex.Match(cellName);

            return match.Value;
        }
        #endregion

        #region GetRowIndex
        // Given a cell name, parses the specified cell to get the row index.
        public static uint GetRowIndex(string cellName)
        {
            // Create a regular expression to match the row index portion the cell name.
            Regex regex = new Regex(@"\d+");
            Match match = regex.Match(cellName);

            return uint.Parse(match.Value);
        }

        #endregion

        #region GetCell
        /// <summary>
        /// Visszaadja oszlop nev es sor index alapjan az adott cellat.
        /// </summary>
        /// <param name="worksheet"></param>
        /// <param name="columnName"></param>
        /// <param name="rowIndex"></param>
        /// <returns></returns>
        public static Cell GetCell(Worksheet worksheet,
                  string columnName, uint rowIndex)
        {
            Row row = GetRow(worksheet, rowIndex);

            if (row == null)
            {
                return null;
            }

            IEnumerable<Cell> cells = row.Elements<Cell>().Where(c => string.Compare
(c.CellReference.Value, columnName +
                   rowIndex, StringComparison.OrdinalIgnoreCase) == 0);
            return !cells.Any() ? null : cells.First();
        }
        #endregion

        #region GetCellValue
        public static string GetCellValue(Worksheet worksheet, SharedStringTable table, string reference)
        {
            var cell = worksheet.Descendants<Cell>().Where(c => string.Compare(c.CellReference.Value, reference, StringComparison.OrdinalIgnoreCase) == 0).FirstOrDefault();
            if (cell == null)
            {
                return null;
            }

            return cell.DataType == CellValues.SharedString ? table.ElementAt(int.Parse(cell.InnerText)).InnerText : cell.InnerText;
        }
        #endregion

        #region GetRow
        /// <summary>
        /// Visszaadja a sor indexe alapjan az adott sor referenciajat.
        /// </summary>
        /// <param name="worksheet"></param>
        /// <param name="rowIndex"></param>
        /// <returns></returns>
        public static Row GetRow(Worksheet worksheet, uint rowIndex)
        {
            IEnumerable<Row> myRows = worksheet.GetFirstChild<SheetData>().
              Elements<Row>().Where(r => r.RowIndex == rowIndex);
            return !myRows.Any() ? null : myRows.First();
        }
        #endregion

        #region GetCellValue2
        /// <summary>
        /// Visszaadja a cella alapjan a hozza tartozo erteket a sharedstring tablabol.
        /// </summary>
        /// <param name="table"></param>
        /// <param name="cell"></param>
        /// <returns></returns>
        public static string GetCellValue(SharedStringTable table, Cell cell)
        {
            int index = -1;
            if (cell.CellValue == null)
            {
                return "";
            }

            if (cell.DataType != null && cell.DataType == CellValues.SharedString && int.TryParse(cell.CellValue.Text, out index))
            {
                return table.Elements<SharedStringItem>().ElementAt(index).InnerText;
            }

            return cell.CellValue.InnerText;
        }
        #endregion

        #region SetColumns
        /// <summary>
        /// beallitja az oszlopokat, elso korben a bestfitet.
        /// </summary>
        public static void SetColumns(Worksheet sheet, int colindex, double maxcolcharacter, bool hidden)
        {
            // ha nem letezik hozza oszlopok tulajdonsag
            Columns cols;
            if (!sheet.Descendants<Columns>().Any())
            {
                cols = new Columns();
                sheet.Append(cols);
            }
            else
            {
                cols = sheet.Descendants<Columns>().First();
            }

            // oszlop letrehozasa, ahol elrejtjuk a validacios listat
            double maxcolwidth = Math.Truncate(((maxcolcharacter * 7 + 5) / 7 * 256) / 256) + 2;
            var col = new Column
            {
                Min = new UInt32Value((uint)colindex),
                Max = new UInt32Value((uint)colindex),
                Width = new DoubleValue(maxcolwidth),
                Hidden = new BooleanValue(hidden),
                BestFit = new BooleanValue(true),
                CustomWidth = new BooleanValue(true)
            };
            cols.Append(col);
        }
        #endregion

        #region Excel columns count
        public static int GetColumnCount(Worksheet sheet)
        {
            var row = sheet.Descendants<Row>().FirstOrDefault();
            return row != null ? row.Descendants<Cell>().Count() : 0;
        }
        #endregion

        #region SetVersion
        public static void SetVersion(Worksheet sheet, string versionNumber)
        {
            // verzió
            // uj cella
            Cell newVersionCell = CreateSpreadsheetCellIfNotExist(sheet, VersionNumberReference);
            // majd index alapjan referenciat adok ra
            var version = !string.IsNullOrWhiteSpace(versionNumber) ? versionNumber : ExcelVersion;
            newVersionCell.CellValue = new CellValue(version);
            // ez bizony egy sharedstring tipus
            newVersionCell.DataType = new EnumValue<CellValues>(CellValues.String);

            SetColumns(sheet, GetColumnIndex(VersionNumberReference), 0, true);
        }
        #endregion

        #region Checkversion
        public static bool CheckVersion(Worksheet sheet, SharedStringTable table, string versionNumber)
        {
            var excelVersion = GetCellValue(sheet, table, VersionNumberReference);

            return versionNumber.Equals(excelVersion);
        }
        #endregion

    }
}