using Million;
using Million.Data;
using Million.DbManagement;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading;
using System.Windows.Forms;

namespace DataSaver
{
    public partial class MainForm : Form
    {
        // Key(임시)
        //public static string accessKey = "4jfMUL3lpwJ5GQSszm3rPp5M47tD8ssfIGew2dDb";
        //public static string secretKey = "iAasVxQt8CyADjzXaAZiF5VZXTZPdElJOP4m97Bz";
        bool flag = false;
        Thread tickThread;
        public MainForm()
        {
            InitializeComponent();

            //CommonProperty.UpbitApi = new Million.WebMangement.Upbit.UpbitAPI(accessKey, secretKey);

            InitForm();            
        }

        /// <summary>
        ///     초기 동작
        /// </summary>
        private void InitForm()
        {
            // 거래소 정보 콤보박스 초기화
            comboBoxEdit_ExchangePlace.Properties.Items.Clear();
            // Million으로부터 거래소 정보 가져오기
            var exchangePlaceNames = Enum.GetNames(enumType: typeof(Million.CommonProperty.ExchangePlace));
            comboBoxEdit_ExchangePlace.Properties.Items.AddRange(exchangePlaceNames);
            
            // 종목 타입 설정
            comboBoxEdit_PaymentType.Properties.Items.AddRange(Enum.GetNames(enumType: typeof(Million.CommonProperty.PaymentType)));
            comboBoxEdit_PaymentType.SelectedIndex = 0;

            // DB 서버 정보 생성
            var strConn = Million.CommonProperty.DbConnectionStr + comboBoxEdit_ExchangePlace.EditValue;
            Million.CommonProperty.ConDbConnectionStr = strConn;

            // Market Table없으면 생성해주기
            foreach (var placeName in exchangePlaceNames)
            {
                var createTableSql = Million.DbManagement.DbServiceFunctions.CreateMarketTableQuery(placeName);
                Million.DbManagement.DBConnection.QueryUpdateExcuter
                    (CommonProperty.DbConnectionMarket, createTableSql);
            }

            /////TODO 임시로 Upbit 우선순위 설정
            comboBoxEdit_ExchangePlace.SelectedIndex = 0;

            for (int i = 0; i < checkedListBox1.Items.Count; i++)
            {
                checkedListBox1.SetItemChecked(i, true);
            }            
        }

        /// <summary>
        ///     거래소 콤보박스 아이템 변경 시 이벤트
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void comboBoxEdit_ExchangePlace_SelectedIndexChanged(object sender, EventArgs e)
        {
            // DB 종목(Market) 정보 가져오기
            Million.DbManagement.DbServiceFunctions.GetMarketTable_FromDB(comboBoxEdit_ExchangePlace.SelectedItem.ToString());
            updateMarketTableOfPlace();

            //초창기 생성시에 데이터가 없음으로 Update이 후 재 처리
            if(CommonProperty.selectedMarketOfPlaceList == null || CommonProperty.selectedMarketOfPlaceList.Count == 0)
                Million.DbManagement.DbServiceFunctions.GetMarketTable_FromDB(comboBoxEdit_ExchangePlace.SelectedItem.ToString());

            // 데이터 입력
            var marketList = CommonProperty.selectedMarketOfPlaceList;
            comboBoxEdit_MarketInfo.Properties.Items.AddRange(marketList.Select(t => t.CoinName).ToList());            
        }

        /// <summary>
        ///     전체 종목(마킷)에 대한 데이터 누적
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button_AllMarketDataAcc_Click(object sender, EventArgs e)
        {
            var dbMarketDataList = CommonProperty.selectedMarketOfPlaceList;
            SetCandleData(comboBoxEdit_ExchangePlace.SelectedItem.ToString(), dbMarketDataList);
        }

        /// <summary>
        ///     선택한 종목에 대한 데이터 누적
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button_SelectedMarketDataAcc_Click(object sender, EventArgs e)
        {
            //Create
            if(!string.IsNullOrWhiteSpace(comboBoxEdit_PaymentType.SelectedItem?.ToString()) &&
               !string.IsNullOrWhiteSpace(comboBoxEdit_MarketInfo.SelectedItem?.ToString())
                )
            {
                var market = comboBoxEdit_PaymentType.SelectedItem.ToString() + "-" + comboBoxEdit_MarketInfo.SelectedItem.ToString();

                var marketList = new List<MarketData>();
                marketList.Add(CommonProperty.selectedMarketOfPlaceList.FirstOrDefault(t => t.CoinFullName == market));

                SetCandleData(comboBoxEdit_ExchangePlace.SelectedItem.ToString(), marketList);
            }
            else
            {
                //Select 하세요
            }
        }

        private void SetCandleData(string placeName, List<MarketData> marketList)
        {
            //Table생성
            CreateTableOfMarket(placeName);

            //거래소 가져오기

            var type = CommonProperty.ExchangeWebReqType.UpbitCandleStick;

            if (placeName.Equals("Bithumb"))
                type = CommonProperty.ExchangeWebReqType.BithumbCandleTicker;

            var list = new List<int>();
            foreach (var item in checkedListBox1.CheckedItems)
            {
                var data = (CommonProperty.MCandleTimeType)Enum.Parse(typeof(CommonProperty.MCandleTimeType), item.ToString());
                list.Add((int)data);
            }

            foreach (var item in list)
            {
                var recentlyDbDataList = Million.DbManagement.DbServiceFunctions.GetOldNewDataList_FromDB
                (marketList, placeName, (CommonProperty.MCandleTimeType)item);

                Million.DbManagement.DbServiceFunctions.SetCandleData(placeName, type, recentlyDbDataList, (CommonProperty.MCandleTimeType)item);
            }
            MessageBox.Show("Completed Set Candle Data");
        }

        /// <summary>
        ///     Market 별 Table 생성
        /// </summary>
        private void CreateTableOfMarket(string placeName)
        {
            var dbMarketDataList = CommonProperty.selectedMarketOfPlaceList;

            // table 명으로 사용할 Name List => Primary key
            var marketNameList = dbMarketDataList.Select(t => t.CoinFullName).ToList();

            string sqlQuery = "";
            // 없는 테이블 먼저 생성
            foreach (var item in marketNameList)
                sqlQuery += Million.DbManagement.DbServiceFunctions.CreateMarketTable_ToDB(item);

            if (!string.IsNullOrWhiteSpace(sqlQuery))
                Million.DbManagement.DBConnection.QueryUpdateExcuter(CommonProperty.DbConnectionStr + placeName, sqlQuery);

        }

        /// <summary>
        ///     선택한 거래소의 종목(Market) 업데이트
        /// </summary>
        private void updateMarketTableOfPlace()
        {
            var dbMarketDataList = CommonProperty.selectedMarketOfPlaceList;

            //거래소 가져오기
            var placeIndex = comboBoxEdit_ExchangePlace.SelectedIndex;
            CommonProperty.recentlyMarketOfPlaceList = new List<MarketData>();

            switch (placeIndex)
            {
                case (int)CommonProperty.ExchangePlace.Upbit:
                    CommonProperty.recentlyMarketOfPlaceList = CommonProperty.UpbitApi.GetMarketDatas();
                    
                    break;
                //case (int)CommonProperty.ExchangePlace.Bithumb:
                //    marketList = Million.DbManagement.DbServiceFunctions.GetMarketTable_FromDB(
                //        comboBoxEdit_ExchangePlace.SelectedItem.ToString());
                //    break;
            }

            // 비교
            // insert (신규)
            var insertData = new List<MarketData>();

            var sqlQuery = "";

            var insertDatasss = CommonProperty.recentlyMarketOfPlaceList
                .Where(x => dbMarketDataList.Count(s => x.CoinFullName == s.CoinFullName) == 0).ToList();

            
            //var insertDatas = CommonProperty.recentlyMarketOfPlaceList.Except(dbMarketDataList).ToList();
                

            foreach (var data in CommonProperty.recentlyMarketOfPlaceList)
            {
                if (!dbMarketDataList.Any(t => t.CoinFullName == data.CoinFullName))
                    sqlQuery += string.Format(
                    "INSERT INTO [dbo].[{0}]([CoinFullName], [ExchangePlace], [KorName], [CoinName], [Payment], [IsValid]) VALUES ('{1}','{2}','{3}','{4}','{5}',{6})",
                    comboBoxEdit_ExchangePlace.SelectedItem, data.CoinFullName,
                    data.ExchangePlace, data.KorName, data.CoinName, data.Payment, 1);
            }

            foreach (var data in dbMarketDataList)
            {
                if (!CommonProperty.recentlyMarketOfPlaceList.Any(t => t.CoinFullName == data.CoinFullName) && data.IsValid)
                    sqlQuery += string.Format(
                    "UPDATE [dbo].[{0}] SET IsValid = 0 WHERE [CoinFullName] = '{1}'",
                    comboBoxEdit_ExchangePlace.SelectedItem,
                    data.CoinFullName);
            }
            if(!string.IsNullOrWhiteSpace(sqlQuery))
                Million.DbManagement.DBConnection.QueryUpdateExcuter(CommonProperty.DbConnectionMarket, sqlQuery);
        }
        /// <summary>
        ///     Delete 기능 추가
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void deletebtn_Click(object sender, EventArgs e)
        {
            var placeName = comboBoxEdit_ExchangePlace.SelectedItem.ToString();
            CreateTableOfMarket(placeName);
            Million.DbManagement.DbServiceFunctions.GetMarketTable_FromDB(placeName);
            
            var dbMarketDataList = CommonProperty.selectedMarketOfPlaceList;

            if (string.IsNullOrWhiteSpace(de_start.Text))
            {
                MessageBox.Show("Start Date 입력바람");
                return;
            }
            if (string.IsNullOrWhiteSpace(de_end.Text)) de_end.Text = DateTime.Now.ToString("yyyyy-MM-dd");

            var startDateTime = Convert.ToDateTime(de_start.Text).ToString("yyyy-MM-dd 00:00:00");
            var endDateTime = Convert.ToDateTime(de_end.Text).ToString("yyyy-MM-dd 00:00:00");
                        
            var sqlQuery = "";
            var count = 0;
            foreach (var item in dbMarketDataList)
            {                
                sqlQuery += string.Format("DELETE FROM [{0}].[dbo].[{1}] WHERE [DateTime] >= '{2}' AND [DateTime] <= '{3}';", placeName, item.CoinFullName, startDateTime, endDateTime);
                count++;
                if (count % 50 == 0)
                {
                    Million.DbManagement.DBConnection.QueryUpdateExcuter(CommonProperty.DbConnectionStr + placeName, sqlQuery);
                    sqlQuery = "";
                }
            }

            if (!string.IsNullOrWhiteSpace(sqlQuery)) Million.DbManagement.DBConnection.QueryUpdateExcuter(CommonProperty.DbConnectionStr + placeName, sqlQuery);


            MessageBox.Show("기간 삭제 완료");
        }

        /// <summary>
        ///     Ticker 시작 -> Upbit KRW 만
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            if (!flag)
            {
                //setting
                flag = true;
                tickThread = new Thread(threadFunction);
                tickThread.Start();
            }
            else
            {
                MessageBox.Show("Ticker Thread 진행 중");
            }
        }


        /// <summary>
        ///      Ticker 쌓기 위한 Thread Function
        /// </summary>
        private void threadFunction()
        {
            var placeName = comboBoxEdit_ExchangePlace.SelectedItem.ToString();
            CreateTableOfMarket(placeName);
            DbServiceFunctions.GetMarketTable_FromDB("Upbit", "KRW");

            // Result Data DB에 생성
            Million.DbManagement.DBConnection.QueryUpdateExcuter
                    (CommonProperty.DbConnectionResultData, DbServiceFunctions.CreateVerifyTickerDataTableQuery());

            //market List
            var dbMarketDataList = CommonProperty.selectedMarketOfPlaceList;

            var coinFullNameList = dbMarketDataList.Select(t => t.CoinFullName).ToList();

            //var date = DateTime.Now;
            //var hour = date.Hour;
            
            var list = new List<Dictionary<string, object>>();
            var saveFlag = true;
            while (flag)
            {
                var date = DateTime.Now;
                var tickerList = CommonProperty.UpbitApi.GetTickerList(coinFullNameList);
                var dic = new Dictionary<string, object>();

                foreach (var item in coinFullNameList)
                {
                    dic[item] = 0;
                }

                if (tickerList.Count != 0)
                {
                    foreach (var item in tickerList)
                    {
                        dic["CoinFullName"] = item.CoinFullName;
                        dic["Price"] = item.TradePrice;
                        dic["DateTime"] = item.DateTime;
                    }
                    list.Add(dic);
                }

                if(date.Minute == 0 && saveFlag)
                {
                    list = list.OrderBy(t => ((DateTime)t["DateTime"])).ToList();

                    var beforeDate = date.AddHours(-1);
                    beforeDate = beforeDate.AddMinutes(-1 * beforeDate.Minute);
                    beforeDate = beforeDate.AddSeconds(-1 * beforeDate.Second);
                    beforeDate = beforeDate.AddMilliseconds(-1 * beforeDate.Millisecond);

                    var recentlyDate = date.AddMinutes(-1 * date.Minute);
                    recentlyDate = recentlyDate.AddSeconds(-1 * date.Second);
                    recentlyDate = recentlyDate.AddMilliseconds(-1 * date.Millisecond);
                    
                    var dicList = list.Where(t => ((DateTime)t["DateTime"]) >= beforeDate && ((DateTime)t["DateTime"]) < recentlyDate).ToList();
                    DBConnection.QueryInsertExcuter_VerifyTickerData(dicList, beforeDate);
                    list.RemoveRange(0, dicList.Count);
                    saveFlag = false;
                }
                else if(date.Minute == 1)
                {
                    saveFlag = true;
                }
                //if(hour < DateTime.Now.Hour)
                //{
                //    //var insertDateTime = date;

                //    //insertDateTime = insertDateTime.AddMinutes(-1 * insertDateTime.Minute);
                //    //insertDateTime = insertDateTime.AddSeconds(-1 * insertDateTime.Second);
                //    //insertDateTime = insertDateTime.AddMilliseconds(-1 * insertDateTime.Millisecond);
                //    //var dicList = list.Where(t => ((DateTime)t["DateTime"]).Hour == hour).ToList();
                //    //DBConnection.QueryInsertExcuter_VerifyTickerData(dicList, insertDateTime);
                //    ////clear 작업
                //    //list = list.OrderBy(t => t["DateTime"]).ToList();
                //    //var index = list.FindLastIndex(t => ((DateTime)t["DateTime"]).Hour == hour);

                //    //list.RemoveRange(0, index + 1);
                    
                //    //date = DateTime.Now;
                //    //hour = date.Hour;                    
                //}

                Thread.Sleep(500);                
            }
        }

        /// <summary>
        ///     Ticker 정지
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button3_Click(object sender, EventArgs e)
        {
            //중지 역할
            if (flag) flag = false;
            Thread.Sleep(1000);
            if (tickThread.IsAlive) tickThread.Abort();
            MessageBox.Show("Ticker Thread Stop 성공");
        }
    }
}