/// <summary>

    ///

    /// </summary>

    /// <typeparam name="OD">original datas type:get from proxy api</typeparam>

    /// <typeparam name="SD">save datas type</typeparam>

    public static class ReportOperation<OD,SD> where OD : class where SD : class

    {

        static int _syncCallApiMaxNum= ConfigHelper.SyncCallApiMaxNum;

        static int _MaxSaveDataNum = ConfigHelper.MaxSaveDataNum;

        static string OriginalDatasType = typeof(OD).FullName;

        static string SaveDatasType = typeof(SD).FullName;

        private static bool TaskSplitForSave(List<ReportSaveTask<SD>> taskList, ILogBase _logger)

        {

            bool saveResult = true;

            try

            {

                _logger.Info($"TaskSplitForSave.SaveDatasType:{SaveDatasType};");

                if (taskList == null || taskList.Count() == 0)

                {

                    return false;

                }

                int index = 0;

                int sumNum = taskList.Count();

                int syncCallApiNum = sumNum > 0 ? _syncCallApiMaxNum : sumNum;

                while (index < sumNum)

                {

                    List<ReportSaveTask<SD>> temp = new List<ReportSaveTask<SD>>();

                    syncCallApiNum = syncCallApiNum > sumNum - index ? sumNum - index : syncCallApiNum;

                    temp = taskList.GetRange(index, syncCallApiNum);

                    index = index + syncCallApiNum;

                    System.Threading.Thread.Sleep(5000);

                    foreach (var oneT in temp)

                    {

                        _logger.Info($"start save Report datas to database. start:{index},num:{syncCallApiNum},request:{JsonConvert.SerializeObject(oneT.Data)}");

                        oneT.SaveResult.Start();

                    }

                    Task.WaitAll(temp.Select(each => each.SaveResult).ToArray());

                    foreach (var teskOne in temp)

                    {

                        var saveTempResult = teskOne.SaveResult.Result;

                        saveResult = saveResult && saveTempResult;

                        if (!saveTempResult)

                        {

                            _logger.Warn($"failed to async Report datas to database!,request:{JsonConvert.SerializeObject(teskOne.Data)}");

                        }

                        else

                        {

                            _logger.Info($"report datas to DB successed!,request:{JsonConvert.SerializeObject(teskOne.Data)}");

                        }

                    }

                }

                _logger.Info($"TaskSplitForSave result:{JsonConvert.SerializeObject(saveResult)};");

                return saveResult;

            }

            catch (Exception ex)

            {

                _logger.Error($"ProxyReportCallSplit:{ex.ToString()}");

                throw ex;

            }

        }

        private static List<ReportSaveTask<SD>> DataSplitForSave(List<SD> reportDB,Func<List<SD>,bool> saveOperate, ILogBase _logger)

        {

            List<ReportSaveTask<SD>> taskList = new List<ReportSaveTask<SD>>();

            try

            {

                _logger.Info($"DataSplitForSave request.reportDB:{JsonConvert.SerializeObject(reportDB)};");

                if (reportDB == null || reportDB.Count() == 0)

                {

                    return null;

                }

                int index = 0;

                int sumNum = reportDB.Count();

                int eachInsert = sumNum > 0 ? _MaxSaveDataNum : sumNum;

                while (index < sumNum)

                {

                    List<SD> temp = new List<SD>();

                    eachInsert = eachInsert > sumNum - index ? sumNum - index : eachInsert;

                    temp = reportDB.GetRange(index, eachInsert);

                    index = index + eachInsert;

                    var taskTemp = new Task<bool>(()=>saveOperate(temp));//_FacebookReportClient.Save(temp)

                    taskList.Add(new ReportSaveTask<SD>() { SaveResult = taskTemp, Data = temp });

                }

                return taskList;

            }

            catch (Exception ex)

            {

                _logger.Error($"save datas to DB error:{ex.ToString()},request:{JsonConvert.SerializeObject(reportDB)}");

                throw ex;

            }

        }

        public static bool ProxyApiSplitToCall(List<Task<List<OD>>> taskList,Func<List<OD>,List<SD>> DateConvertToDB, Func<List<SD>,bool> saveOperate, ILogBase _logger)

        {

            bool result = true;

            try

            {

                _logger.Info($"ProxyApiSplitToCall");

                if (taskList == null || taskList.Count() == 0)

                {

                    return false;

                }

                int index = 0;

                int sumNum = taskList.Count();

                int syncCallApiNum = sumNum > 0 ? _syncCallApiMaxNum : sumNum;

                while (index < sumNum)

                {

                    syncCallApiNum = syncCallApiNum > sumNum - index ? sumNum - index : syncCallApiNum;

                    List<Task<List<OD>>> temp = taskList.GetRange(index, syncCallApiNum);

                    index = index + syncCallApiNum;

                    System.Threading.Thread.Sleep(5000);

                    foreach (var oneT in temp)

                    {

                        oneT.Start();

                    }

                    Task.WaitAll(temp.ToArray());

                    #region save data

                    List<OD> allReports = new List<OD>();

                    CommandHelper.UnionAllTaskResult<OD>(temp, ref allReports);

                    if (allReports == null || allReports.Count() == 0)

                    {

                        _logger.Warn($"no datas can get from proxy call![{JsonConvert.SerializeObject(allReports)}]");

                        continue;

                    }

                    _logger.Info($"datas get from proxy call:{JsonConvert.SerializeObject(allReports)}");

                    List<SD> reportDB = DateConvertToDB(allReports);

                    if (reportDB == null || reportDB.Count() == 0)

                    {

                        _logger.Warn($"no datas need to be created or updated:{JsonConvert.SerializeObject(reportDB)}");

                        continue;

                    }

                    _logger.Info($"datas need to be save :{JsonConvert.SerializeObject(reportDB)}");

                    List<ReportSaveTask<SD>> DataSaveT= DataSplitForSave(reportDB, saveOperate, _logger);

                    bool saveResult = TaskSplitForSave(DataSaveT, _logger);

                    _logger.Info($"datas save result:{JsonConvert.SerializeObject(saveResult)}");

                    #endregion

                    result = result & saveResult;

                }

                return result;

            }

            catch (Exception ex)

            {

                _logger.Error($"ProxyReportCallSplit:{ex.ToString()}");

                throw ex;

            }

        }

    }

bool saveResult = ReportOperation<FacebookDailyReportConvertFromClient, FacebookImpressDeviceReport>.ProxyApiSplitToCall(taskList, dataConvertFunc, dataSaveFunc, _logger);

                Func<List<FacebookDailyReportConvertFromClient>, List<FacebookImpressDeviceReport>> dataConvertFunc = (originalData) => { return DateConvertToDB(originalData, accounts); };

                Func<List<FacebookImpressDeviceReport>, bool> dataSaveFunc = (saveDB) => { return SaveReportsToDB(saveDB); };

                bool saveResult = ReportOperation<FacebookDailyReportConvertFromClient, FacebookImpressDeviceReport>.ProxyApiSplitToCall(taskList, dataConvertFunc, dataSaveFunc, _logger);

    /// <summary>

    /// get reoports from proxy client

    /// </summary>

    /// <typeparam name="RQ">request type</typeparam>

    /// <typeparam name="RP">response list type</typeparam>

    /// <typeparam name="CRQ">proxy client request type</typeparam>

    /// <typeparam name="CRP">proxy client response type</typeparam>

    public abstract class ReportDownloadBase<RQ, RP,CRQ,CRP> where RQ : class where RP : class where CRQ : class where CRP : class

    {

        protected string exportPath;

        protected System.Collections.Specialized.NameValueCollection appSettings;

        protected ILogBase _logger;

        protected string _plantform;

        public ReportDownloadBase(ILogBase logger,string plantform)

        {

            _plantform = plantform;

            appSettings = WestWin.Common.Configuration.ConfigurationManager.Default.AppSettings;

            exportPath = Path.Combine(System.IO.Directory.GetCurrentDirectory(), appSettings["ReportRawPath"], plantform);

            _logger = logger;

        }

        /// <summary>

        /// Generate ReportRequest for proxy client

        /// </summary>

        /// <param name="req">request</param>

        /// <returns></returns>

        protected abstract CRQ GenerateReportRequest(RQ req);

        /// <summary>

        /// Generate Results to return

        /// </summary>

        /// <param name="resp">ReportResponse</param>

        /// <param name="breakdownValue">breakdownValue </param>

        /// <returns>result list</returns>

        protected abstract List<RP> GenerateResultsByReportResponse(CRP resp, RQ req);

        /// <summary>

        /// get client response from client request

        /// </summary>

        /// <param name="req"></param>

        /// <returns></returns>

        protected abstract CRP GetResponseFromRequest(CRQ req);

        /// <summary>

        /// Get Results By Request

        /// </summary>

        /// <param name="request"></param>

        /// <param name="breakdownValue"></param>

        /// <returns></returns>

        protected List<RP> Process(RQ request,string breakdownValue)

        {

            try

            {

            _logger.Info($"{_plantform} GetReport request:{JsonConvert.SerializeObject(request)}");

            var req = GenerateReportRequest(request);

            _logger.Info($"{_plantform} proxy client request:{JsonConvert.SerializeObject(req)}");         

                CRP response = null;

                int maxTry = ConfigHelper.ApiTryMaxNum;

                int count = 0;

                while (count < maxTry)

                {

                    count++;

                    response = null;

                    try

                    {

                        response = GetResponseFromRequest(req);

                    }

                    catch (Exception e)

                    {

                        _logger.Error($"{_plantform} proxy client get report failed:Round {count}", e);

                        if(count== maxTry)

                        {

                            _logger.Error($"{_plantform} proxy client get report: exception & retry time:{count}", e);

                            throw e;

                        }

                    }

                    if (response != null) break;

                    _logger.Warn($"{_plantform} proxy client get report failed:retry Num: {count},request:{JsonConvert.SerializeObject(req)}");

                    System.Threading.Thread.Sleep(5000);

                }

                if (response == null)

                {

                    return null;

                }

                _logger.Info($"{_plantform} proxy client Get Report sucess:{JsonConvert.SerializeObject(response)}");

                var result = GenerateResultsByReportResponse(response, request);

                _logger.Info($"{_plantform} return Report result:{JsonConvert.SerializeObject(result)}");

                CommandHelper.CreateDictionaryIfNotExists(exportPath);

                if (result == null || result.Count == 0)

                {

                    _logger.Warn($"{_plantform} return empty result for request:{JsonConvert.SerializeObject(req)}");

                }

                else

                {

                    var path = Path.Combine(exportPath, $"{_plantform}-row-{breakdownValue}-{DateTime.Now.ToString("yyyyMMddHHmmss")}-{Guid.NewGuid().ToString()}.csv");

                    bool saveSucess = CommandHelper.SaveDataToCSVFile<RP>(result, path);

                    _logger.Info($"{_plantform} report save local file result:{saveSucess}");

                }

                return result;

            }

            catch (Exception ex)

            {

                _logger.Error($"exception. request.request: {JsonConvert.SerializeObject(request)};  request.breakdownValue: {JsonConvert.SerializeObject(breakdownValue)};error:{ex.ToString()}");

                throw ex;

            }

        }

    }

    public class FacebookCountryCmd : ReportDownloadBase<FacebookDailyReportEachRequest, FacebookDailyReportConvertFromClient, FacebookGetAdsInsightRequest, FacebookGetAdsInsightsResponse>, IFacebookCountryCmd

    {

        IFacebookCountryReportService _facebookCountryReportService;

        IFacebookProxyService _FacebookProxyClient;

        IAccountCampaignOperation _campaignOperation;

        IFacebookCampaignHelper _facebookCampaignHelper;

        Platform.Service.Enterprise.AccountChannel _accountChannel = Platform.Service.Enterprise.AccountChannel.Facebook;

        Dictionary<string, FacebookSearchAdgeolocationEntity> _countryDic=new Dictionary<string, FacebookSearchAdgeolocationEntity>();

        public FacebookCountryCmd(ILogBase logger,

            IFacebookCountryReportService facebookCountryReportService, IAccountCampaignOperation campaignOperation,

            IFacebookProxyService FacebookProxyClient,IFacebookCampaignHelper facebookCampaignHelper) : base(logger, "facebook")

        {

            _facebookCountryReportService = facebookCountryReportService;

            _FacebookProxyClient = FacebookProxyClient;

            _campaignOperation = campaignOperation;

            _facebookCampaignHelper = facebookCampaignHelper;

            GetAllCountry();

        }

        public List<FacebookCountryReport> DateConvertToDB(List<FacebookDailyReportConvertFromClient> reportDatas, List<BusinessAdsPlatformAccountDetail> accounts)

        {

            //*****

        }

        public void Execute(FacebookCmdOptions opt)

        {

            //*****

        }

        public bool SaveReportsToDB(List<FacebookCountryReport> reportDB)

        {

            //****

        }

        protected override FacebookGetAdsInsightRequest GenerateReportRequest(FacebookDailyReportEachRequest req)

        {

            //****

        }

        protected override List<FacebookDailyReportConvertFromClient> GenerateResultsByReportResponse(FacebookGetAdsInsightsResponse response, FacebookDailyReportEachRequest req)

        {

           //***

        }

        protected override FacebookGetAdsInsightsResponse GetResponseFromRequest(FacebookGetAdsInsightRequest req)

        {

            //****

        }

        private bool IfNextPage(FacebookGetAdsInsightsResponse response, ref FacebookGetAdsInsightRequest request)

        {

            //****

        }

    }

    public interface IFacebookCountryCmd: IReportCmdBase<FacebookCountryReport, FacebookCmdOptions, FacebookDailyReportConvertFromClient>

    {

    }

    /// <summary>

    /// execute download report

    /// </summary>

    /// <typeparam name="RDB">report type define by DB</typeparam>

    /// <typeparam name="CMD">command type</typeparam>

    /// <typeparam name="RP">report response including all data get from proxy client</typeparam>

    public interface IReportCmdBase<RDB,CMD,RP> where RDB : class where CMD:class where RP:class

    {

        /// <summary>

        /// Save Reports To DB

        /// </summary>

        /// <param name="reportDB"></param>

        /// <returns></returns>

        bool SaveReportsToDB(List<RDB> reportDB);

        /// <summary>

        /// convert report to match datebase define

        /// </summary>

        /// <param name="reportDatas"></param>

        /// <returns></returns>

        List<RDB> DateConvertToDB(List<RP> reportDatas, List<BusinessAdsPlatformAccountDetail> accounts);

        /// <summary>

        /// Execute Download Report :get from proxy client api & save original data to local file & save to DB

        /// </summary>

        /// <param name="opt">command</param>

        void Execute(CMD opt);

    }