using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Web.UI.WebControls;

namespace CoreSavingLibrary
{
    public class DataSourceRepeater : DataSourceTool
    {
        private char sym1 = '†';
        private char sym2 = '‡';

        public DataTable Deleted
        {
            get
            {
                DataTable deleted = null;
                try
                {
                    List<String> dataColumn = PrimaryKeys;
                    if (deleted == null)
                    {
                        deleted = new DataTable("Deleted");
                        for (int k = 0; k < dataColumn.Count; k++)
                        {
                            deleted.Columns.Add(dataColumn[k], baseDataTable.Columns[dataColumn[k]].DataType);
                        }
                    }
                    string[] split2 = this.deleteCode.Split(sym2);
                    DataRow delRow;
                    for (int i = 0; i < split2.Length; i++)
                    {
                        delRow = deleted.NewRow();
                        string[] split1 = split2[i].Split(sym1);
                        for (int c = 0; c < dataColumn.Count; c++)
                        {
                            if (IsDateType(baseDataTable.Columns[dataColumn[c]]))
                            {
                                delRow[c] = DateTime.ParseExact(split1[c], "yyyy-MM-dd HH:mm:ss", en);
                            }
                            else
                            {
                                delRow[c] = Convert.ChangeType(split1[c], baseDataTable.Columns[dataColumn[c]].DataType);
                            }
                        }
                        deleted.Rows.Add(delRow);
                    }
                }
                catch { }
                return deleted;
            }
        }

        protected void InitDataSource(PageWeb pw, Repeater objectRepeater, DataTable dtMask, String jsRefName)
        {
            this.repeaterDefault = objectRepeater;
            SecondStructor(pw, dtMask, jsRefName);
        }

        protected void Register()
        {
            this.baseDataTable.Clear();
            if (!pageWebSheetDefault.IsPostBack)
            {
                repeaterDefault.DataSource = this.baseDataTable;
                repeaterDefault.DataBind();
            }
            else
            {
                int maxRow = int.Parse(pageWebSheetDefault.Request["name_maxrow_databinder_" + this.jsRefName]);
                int rowFocus = int.Parse(pageWebSheetDefault.Request["name_rowfocus_databinder_" + this.jsRefName]);
                this.SetRowFocus(rowFocus);
                String delCode = pageWebSheetDefault.Request["name_deletecode_databinder_" + this.jsRefName];
                this.deleteCode = delCode;
                for (int i = 0; i < maxRow; i++)
                {
                    DataRow dr = this.baseDataTable.NewRow();
                    for (int c = 0; c < baseDataTable.Columns.Count; c++)
                    {
                        if (!string.IsNullOrEmpty(baseDataTable.Columns[c].Expression)) continue;
                        object var = null;
                        string ts = baseDataTable.Columns[c].DataType.FullName.ToLower();
                        string columnName = baseDataTable.Columns[c].ColumnName.ToLower();
                        if (ts == "system.datetime")
                        {
                            var = reDate(i, columnName);
                        }
                        else if (ts == "system.int32")
                        {
                            var = reInt(i, columnName);
                        }
                        else if (ts == "system.int64")
                        {
                            var = reLong(i, columnName);
                        }
                        else if (ts == "system.decimal")
                        {
                            var = reDec(i, columnName);
                        }
                        else
                        {
                            var = re(i, columnName);
                        }
                        try
                        {
                            dr[c] = var;
                        }
                        catch { }
                    }
                    try
                    {
                        dr["row_status"] = pageWebSheetDefault.Request["name_rowstatus_databinder_" + this.jsRefName + "_" + i];
                    }
                    catch { }
                    this.baseDataTable.Rows.Add(dr);
                }
            }
            pageWebSheetDefault.binder.Add(this);
        }

        /// <summary>
        /// เพิ่มแถวต่อท้าย 1 แถว
        /// </summary>
        /// <returns></returns>
        public int InsertLastRow()
        {
            return InsertLastRow(1);
        }

        public int InsertLastRow(int numRow)
        {
            return InsertLastRow(numRow, -1);
        }

        private int InsertLastRow(int numRow, int atRow)
        {
            int result = -1;
            for (int i = 0; i < numRow; i++)
            {
                DataRow dr = this.baseDataTable.NewRow();
                for (int c = 0; c < baseDataTable.Columns.Count; c++)
                {
                    DataColumn col = baseDataTable.Columns[c];
                    string colName = baseDataTable.Columns[c].ColumnName;
                    if (IsDateType(col)) //date type
                    {
                        try
                        {
                            if (col.DefaultValue == DBNull.Value || col.DefaultValue == null)
                            {
                                dr[c] = new DateTime(1500, 1, 1);
                            }
                            else
                            {
                                dr[c] = col.DefaultValue;
                            }
                        }
                        catch
                        {
                            dr[c] = new DateTime(1500, 1, 1);
                        }
                    }
                    else if (IsNumberType(col)) //number type
                    {
                        try
                        {
                            if (col.DefaultValue == DBNull.Value || col.DefaultValue == null)
                            {
                                dr[c] = 0;
                            }
                            else
                            {
                                dr[c] = col.DefaultValue;
                            }
                        }
                        catch
                        {
                            dr[c] = 0;
                        }
                    }
                    else
                    {
                        try
                        {
                            if (col.DefaultValue == DBNull.Value || col.DefaultValue == null)
                            {
                                dr[c] = "";
                            }
                            else
                            {
                                dr[c] = col.DefaultValue;
                            }
                        }
                        catch
                        {
                            dr[c] = "";
                        }
                    }
                }
                try
                {
                    dr["row_status"] = "insert";
                }
                catch { }
                if (atRow < 0)
                {
                    this.baseDataTable.Rows.Add(dr);
                }
                else
                {
                    this.baseDataTable.Rows.InsertAt(dr, atRow);
                }
            }
            repeaterDefault.DataSource = this.baseDataTable;
            repeaterDefault.DataBind();
            result = this.baseDataTable.Rows.Count;
            return result;
        }

        public void InsertAtRow(int row)
        {
            this.InsertLastRow(1, row);
        }

        public void DeleteRow(int row)
        {
            String rowStatus = "";
            try
            {
                rowStatus = baseDataTable.Rows[row]["row_status"].ToString();
            }
            catch
            {
                rowStatus = "";
            }
            if (rowStatus == "update" || rowStatus == "none")
            {
                try
                {
                    List<String> dataColumn = PrimaryKeys;
                    String code = "";
                    for (int c = 0; c < dataColumn.Count; c++)
                    {
                        String value = "";
                        if (this.IsDateType(dataColumn[c]))
                        {
                            value = Convert.ToDateTime(this.baseDataTable.Rows[row][dataColumn[c]]).ToString("yyyy-MM-dd HH:mm:ss", en);
                        }
                        else
                        {
                            value = this.baseDataTable.Rows[row][dataColumn[c]].ToString();
                        }
                        if (code == "")
                        {
                            code = value;
                        }
                        else
                        {
                            code += sym1 + value;
                        }
                    }
                    if (this.deleteCode == "")
                    {
                        this.deleteCode = code;
                    }
                    else
                    {
                        this.deleteCode += sym2 + code;
                    }
                }
                catch { }
            }
            this.baseDataTable.Rows.RemoveAt(row);
            repeaterDefault.DataSource = this.baseDataTable;
            repeaterDefault.DataBind();
        }

        public String GetRowStatus(int row)
        {
            return baseDataTable.Rows[row]["row_status"].ToString();
        }

        public List<String> CreateSyntax()
        {
            List<String> syntax = new List<string>();
            String where;
            if (deleteCode != "")
            {
                String[] code = this.deleteCode.Split(sym2);
                for (int i = 0; i < code.Length; i++)
                {
                    int ic = 0;
                    String[] subCode = code[i].Split(sym1);
                    where = "";
                    for (int c = 0; c < baseDataTable.Columns.Count; c++)
                    {
                        if (IsPrimaryKey(baseDataTable.Columns[c]))
                        {
                            String value = "";
                            if (IsDateType(baseDataTable.Columns[c])) //date type
                            {
                                value = "to_date('" + subCode[ic] + "', 'yyyy-mm-dd hh24:mi:ss')";
                            }
                            else if (IsNumberType(baseDataTable.Columns[c])) //number type
                            {
                                value = subCode[ic];
                            }
                            else
                            {
                                value = "'" + subCode[ic] + "'";
                            }
                            if (where == "")
                            {
                                where += baseDataTable.Columns[c].ColumnName + " = " + value;
                            }
                            else
                            {
                                where += " and " + baseDataTable.Columns[c].ColumnName + " = " + value;
                            }
                            ic++;
                            if (ic >= subCode.Length)
                            {
                                break;
                            }
                        }
                    }
                    syntax.Add("delete from " + this.TableName + " where " + where);
                }
            }
            for (int i = 0; i < this.baseDataTable.Rows.Count; i++)
            {
                String status = this.GetRowStatus(i);
                if (status == "insert")
                {
                    syntax.Add(this.SyntaxInsert(i));
                }
                else if (status == "update")
                {
                    syntax.Add(this.SyntaxUpdate(i));
                }
            }
            return syntax;
        }

        public void EditRow(int row)
        {
            try
            {
                String rowStatus = this.baseDataTable.Rows[row]["row_status"].ToString();
                if (rowStatus == "none")
                {
                    this.baseDataTable.Rows[row]["row_status"] = "update";
                }
            }
            catch { }
        }

        public int GetRowMaxValue(String column)
        {
            int result = 0;
            object value = null;
            for (int i = 0; i <= this.baseDataTable.Rows.Count; i++)
            {
                if (i == 0)
                {
                    try
                    {
                        value = this.baseDataTable.Rows[i][column];
                    }
                    catch { }
                }
                if (IsDateType(column))
                {
                    if (value == null)
                    {
                        value = new DateTime(1500, 0, 0);
                    }
                    DateTime dt = Convert.ToDateTime(this.baseDataTable.Rows[i][column]);
                    try
                    {
                        if (dt > Convert.ToDateTime(value))
                        {
                            value = dt;
                            result = i;
                        }
                    }
                    catch { }
                }
                else if (IsNumberType(column))
                {
                    if (value == null)
                    {
                        value = 0;
                    }
                    try
                    {
                        decimal deci = Convert.ToDecimal(this.baseDataTable.Rows[i][column]);
                        if (deci > Convert.ToDecimal(value))
                        {
                            value = deci;
                            result = i;
                        }
                    }
                    catch { }
                }
                else
                {
                    if (value == null)
                    {
                        value = "";
                    }
                    try
                    {
                        String v = this.baseDataTable.Rows[i][column].ToString();
                        if (v.CompareTo(value) > 0)
                        {
                            value = v;
                            result = i;
                        }
                    }
                    catch { }
                }
            }
            return result;
        }

        public decimal GetMaxValueDecimal(String column)
        {
            try
            {
                return Convert.ToDecimal(baseDataTable.Rows[GetRowMaxValue(column)][column]);
            }
            catch
            {
                return 0;
            }
        }

        public string GetMaxValueString(String column)
        {
            try
            {
                return Convert.ToString(baseDataTable.Rows[GetRowMaxValue(column)][column]);
            }
            catch
            {
                return "";
            }
        }

        public DateTime GetMaxValueDateTime(String column)
        {
            try
            {
                return Convert.ToDateTime(baseDataTable.Rows[GetRowMaxValue(column)][column]);
            }
            catch
            {
                return new DateTime(1500, 1, 1); ;
            }
        }

        public int GetRowMinValue(String column)
        {
            int result = 0;
            object value = null;
            for (int i = 0; i <= this.baseDataTable.Rows.Count; i++)
            {
                if (i == 0)
                {
                    try
                    {
                        value = this.baseDataTable.Rows[i][column];
                    }
                    catch { }
                }
                if (IsDateType(column))
                {
                    if (value == null)
                    {
                        value = new DateTime(1500, 0, 0);
                    }
                    try
                    {
                        DateTime dt = Convert.ToDateTime(this.baseDataTable.Rows[i][column]);
                        if (dt < Convert.ToDateTime(value))
                        {
                            value = dt;
                            result = i;
                        }
                    }
                    catch { }
                }
                else if (IsNumberType(column))
                {
                    if (value == null)
                    {
                        value = 0;
                    }
                    try
                    {
                        decimal deci = Convert.ToDecimal(this.baseDataTable.Rows[i][column]);
                        if (deci < Convert.ToDecimal(value))
                        {
                            value = deci;
                            result = i;
                        }
                    }
                    catch { }
                }
                else
                {
                    if (value == null)
                    {
                        value = "";
                    }
                    try
                    {
                        String v = this.baseDataTable.Rows[i][column].ToString();
                        if (v.CompareTo(value) < 0)
                        {
                            value = v;
                            result = i;
                        }
                    }
                    catch { }
                }
            }
            return result;
        }

        public decimal GetMinValueDecimal(String column)
        {
            try
            {
                return Convert.ToDecimal(baseDataTable.Rows[GetRowMinValue(column)][column]);
            }
            catch
            {
                return 0;
            }
        }

        public string GetMinValueString(String column)
        {
            try
            {
                return Convert.ToString(baseDataTable.Rows[GetRowMinValue(column)][column]);
            }
            catch
            {
                return "";
            }
        }

        public DateTime GetMinValueDateTime(String column)
        {
            try
            {
                return Convert.ToDateTime(baseDataTable.Rows[GetRowMinValue(column)][column]);
            }
            catch
            {
                return new DateTime(1500, 1, 1); ;
            }
        }

        public String ExportXmlModifyRow()
        {
            if (this.baseDataTable.Rows.Count <= 0)
            {
                return "";
            }
            string table = this.TableName.ToLower();
            StringBuilder resu = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\n");
            resu.Append("<iscxml_data_table table_name=\"" + table + "\">\n");
            int thePkIndex = 0;
            for (int i = 0; i < this.baseDataTable.Rows.Count; i++)
            {
                string type = "";
                string pkIndex = "";
                string external = "";
                string defaultValue = "";
                if (baseDataTable.Rows[i]["row_status"].ToString().ToLower() == "none")
                {
                    continue;
                }
                resu.Append("\t<iscxml_data_row>");
                for (int c = 0; c < baseDataTable.Columns.Count; c++)
                {
                    if (baseDataTable.Columns[c].ColumnName.ToLower() == "running_number")
                    {
                        continue;
                    }
                    if (i <= 0)
                    {
                        if (IsReadOnly(baseDataTable.Columns[c]))
                        {
                            external = " external=\"1\"";
                        }
                        else
                        {
                            external = "";
                        }
                        if (IsPrimaryKey(baseDataTable.Columns[c]))
                        {
                            thePkIndex++;
                            pkIndex = " pk_index=\"" + thePkIndex + "\"";
                            external = "";
                        }
                        else
                        {
                            pkIndex = "";
                        }
                        if (IsDateType(baseDataTable.Columns[c]))
                        {
                            try
                            {
                                defaultValue = " default=\"" + Convert.ToDateTime(baseDataTable.Columns[c].DefaultValue).ToString("yyyy-MM-dd HH:mm:ss", en) + "\"";
                            }
                            catch
                            {
                                defaultValue = "";
                            }
                            type = " type=\"date\"";
                        }
                        else if (IsNumberType(baseDataTable.Columns[c]))
                        {
                            try
                            {
                                defaultValue = " default=\"" + baseDataTable.Columns[c].DefaultValue + "\"";
                            }
                            catch
                            {
                                defaultValue = "";
                            }
                            type = " type=\"number\"";
                        }
                        else
                        {
                            try
                            {
                                defaultValue = " default=\"" + baseDataTable.Columns[c].DefaultValue + "\"";
                            }
                            catch
                            {
                                defaultValue = "";
                            }
                            type = "";
                        }

                    }
                    String value = "";
                    try
                    {
                        if (IsDateType(baseDataTable.Columns[c])) //date type
                        {
                            DateTime dt = new DateTime(1500, 1, 1);
                            try
                            {
                                dt = Convert.ToDateTime(this.baseDataTable.Rows[i][c]);
                            }
                            catch { }
                            if (dt.Year >= 1700)
                            {
                                value = dt.ToString("yyyy-MM-dd HH:mm:ss", en);
                            }
                            else
                            {
                                value = "";
                            }
                        }
                        else if (IsNumberType(baseDataTable.Columns[c])) //number type
                        {
                            try
                            {
                                value = Convert.ToDecimal(this.baseDataTable.Rows[i][c]) + "";
                            }
                            catch
                            {
                                value = "0";
                            }
                        }
                        else
                        {
                            try
                            {
                                value = this.baseDataTable.Rows[i][c].ToString();
                            }
                            catch { }
                        }
                    }
                    catch { }
                    resu.Append("\t\t<" + baseDataTable.Columns[c].ColumnName.ToLower() + type + pkIndex + external + defaultValue + ">");
                    resu.Append(value);
                    resu.Append("</" + baseDataTable.Columns[c].ColumnName.ToLower() + ">\n");
                }
                resu.Append("\t</iscxml_data_row>\n");
            }
            DataTable del = null;
            int delRow = 0;
            try
            {
                del = this.Deleted;
                delRow = del.Rows.Count;
            }
            catch
            {
                delRow = 0;
            }
            for (int i = 0; i < delRow; i++)
            {
                resu.Append("\t<iscxml_data_row deleted=\"true\">");
                for (int c = 0; c < baseDataTable.Columns.Count; c++)
                {
                    string colName = baseDataTable.Columns[c].ColumnName.ToLower();
                    if (colName == "running_number")
                    {
                        continue;
                    }
                    String value = "";
                    try
                    {
                        if (IsPrimaryKey(baseDataTable.Columns[c]))
                        {
                            if (IsDateType(baseDataTable.Columns[c])) //date type
                            {
                                DateTime dt = new DateTime(1500, 1, 1);
                                try
                                {
                                    dt = Convert.ToDateTime(del.Rows[i][colName]);
                                }
                                catch { }
                                if (dt.Year >= 1700)
                                {
                                    value = dt.ToString("yyyy-MM-dd HH:mm:ss", en);
                                }
                                else
                                {
                                    value = "";
                                }
                            }
                            else if (IsNumberType(baseDataTable.Columns[c])) //number type
                            {
                                try
                                {
                                    value = Convert.ToDecimal(del.Rows[i][colName]) + "";
                                }
                                catch
                                {
                                    value = "0";
                                }
                            }
                            else
                            {
                                try
                                {
                                    value = del.Rows[i][colName].ToString();
                                }
                                catch { }
                            }
                        }
                    }
                    catch { }
                    resu.Append("\t\t<" + baseDataTable.Columns[c].ColumnName.ToLower() + ">");
                    resu.Append(value);
                    resu.Append("</" + baseDataTable.Columns[c].ColumnName.ToLower() + ">\n");
                }
                resu.Append("\t</iscxml_data_row>\n");
            }
            resu.Append("</iscxml_data_table>");
            return resu.ToString();
        }

        public void ResetRow()
        {
            DataTable dt = null;
            this.ImportData(dt);
        }

        public void ChangeRowStatusInsert(int row)
        {
            this.baseDataTable.Rows[row]["row_status"] = "insert";
        }

        public void ChangeRowStatusInsert()
        {
            this.deleteCode = "";
            for (int i = 0; i < baseDataTable.Rows.Count; i++)
            {
                ChangeRowStatusInsert(i);
            }
        }

        public void ChangeRowStatusUpdate(int row)
        {
            this.baseDataTable.Rows[row]["row_status"] = "update";
        }

        public void ChangeRowStatusUpdate()
        {
            for (int i = 0; i < baseDataTable.Rows.Count; i++)
            {
                ChangeRowStatusUpdate(i);
            }
        }

        public void ChangeRowStatusNone(int row)
        {
            this.baseDataTable.Rows[row]["row_status"] = "none";
        }

        public void ChangeRowStatusNone()
        {
            for (int i = 0; i < baseDataTable.Rows.Count; i++)
            {
                ChangeRowStatusNone(i);
            }
        }
    }
}