using OrpaonEMS.App.Models;
using OrpaonEMS.Model;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;

namespace OrpaonEMS.App.Services
{
    /// <summary>
    /// 月浦
    /// 数据分析模型
    /// 数据统计模型
    /// </summary>
    public class YuPuPwAnalyzeService : BindableBase
    {
        /// <summary>
        /// 周期定时器
        /// </summary>
        private System.Timers.Timer CycleTimer { get; set; }

        public ILogService LogService { get; }

        /// <summary>
        /// 实例化函数
        /// </summary>
        public YuPuPwAnalyzeService(ILogService logService,
            IFreeSql freeSql,
            ConfigDataService configDataService,
            //SolarEnergyService solarEnergyService,
            YuePuRunModelService yuePuRunModelService
            )
        {

            LogService = logService;
            this.freeSql = freeSql;
            ConfigDataService = configDataService;
            //SolarEnergyService = solarEnergyService;
            YuePuRunModelService = yuePuRunModelService;
            //InPowerPCSDataService = inPowerPCSDataService;

            if (ConfigDataService.IsMaster)
            {
                //10秒触发一次
                CycleTimer = new System.Timers.Timer(10000);
                CycleTimer.Elapsed += CycleAction;
                CycleTimer.AutoReset = true;
                CycleTimer.Enabled = true;

                LogService.Info($"时间:{DateTime.Now.ToString()}-【PwAnalyze-开始了");

                _CurMinInfo = DateTime.Now.Minute;

                LoadInitialYuPuHourDataByDb();
            }
           

            
            //LoadInitStartData();

        }

        /// <summary>
        /// 周期调用这个方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void CycleAction(object? sender, ElapsedEventArgs e)
        {
            try
            {
                //如果Execute执行的是一个很耗时的方法，会导致方法未执行完毕，定时器又启动了一个线程来执行Execute方法
                CycleTimer.Stop(); //先关闭定时器

                ////先给值
                //CurHourInfo = DateTime.Now.Hour;

                CurMinInfo = DateTime.Now.Minute;
                CurDayInfo = DateTime.Now.Day;
                CurMonthInfo = DateTime.Now.Month;
                CurYearInfo = DateTime.Now.Year;

                CycleTimer.Start(); //执行完毕后再开启器
            }
            catch (Exception ex)
            {
                CycleTimer.Start(); //执行完毕后再开启器
                LogService.Info($"时间:{DateTime.Now.ToString()}-【PwAnalyze-CycleAction】-{ex.Message}");
            }
        }


        private ObservableCollection<YuPuHourData> _ListLastYuPuHourData = new ObservableCollection<YuPuHourData>();
        /// <summary>
        /// 日小数数据集合
        /// </summary>
        public ObservableCollection<YuPuHourData> ListLastYuPuHourData
        {
            get { return _ListLastYuPuHourData; }
            set { _ListLastYuPuHourData = value; RaisePropertyChanged(); }
        }

        #region 年月日 时分 触发动作

        private int _CurMinInfo;
        /// <summary>
        /// 当前的分钟信息
        /// 用分钟用于触发小时的数据
        /// </summary>
        private int CurMinInfo
        {
            get { return _CurMinInfo; }
            set
            {
                EsManageAnalyse.TotalChargPw = YuePuRunModelService.EsEleMeter1.EleQ_P;
                EsManageAnalyse.TotalDisChargPw = YuePuRunModelService.EsEleMeter1.EleQ_N;
                //日充放电量
                EsManageAnalyse.DayChargPw = YuePuRunModelService.EsEleMeter1.EleQ_P - EsManageAnalyse.DayStartPointChargPw;
                EsManageAnalyse.DayDisChargPw = YuePuRunModelService.EsEleMeter1.EleQ_N - EsManageAnalyse.DayStartPointDisChargPw;
                //月充放电量
                EsManageAnalyse.MonthChargPw = EsManageAnalyse.TotalChargPw - EsManageAnalyse.MonthStartPointChargPw;
                EsManageAnalyse.MonthDisChargPw = EsManageAnalyse.TotalDisChargPw - EsManageAnalyse.MonthStartPointDisChargPw;
                //年充放电量
                EsManageAnalyse.YearChargPw = EsManageAnalyse.TotalChargPw - EsManageAnalyse.YearStartPointChargPw;
                EsManageAnalyse.YearDisChargPw = EsManageAnalyse.TotalDisChargPw - EsManageAnalyse.YearStartPointDisChargPw;

                SolarTaxAnalyse.TotalChargPw = YuePuRunModelService.SolarEleMeter3.EleQ_N;
                SolarTaxAnalyse.DayChargPw = YuePuRunModelService.SolarEleMeter3.EleQ_N - SolarTaxAnalyse.DayStartPointPw;
                SolarTaxAnalyse.MonthChargPw = YuePuRunModelService.SolarEleMeter3.EleQ_N - SolarTaxAnalyse.MonthStartPointPw;
                SolarTaxAnalyse.YearChargPw = YuePuRunModelService.SolarEleMeter3.EleQ_N - SolarTaxAnalyse.YearStartPointPw;

                SolarManageAnalyse.TotalChargPw = YuePuRunModelService.SolarEleMeter2.EleQ_N;
                SolarManageAnalyse.DayChargPw = YuePuRunModelService.SolarEleMeter2.EleQ_N - SolarManageAnalyse.DayStartPointPw;
                SolarManageAnalyse.MonthChargPw = YuePuRunModelService.SolarEleMeter2.EleQ_N - SolarManageAnalyse.MonthStartPointPw;
                SolarManageAnalyse.YearChargPw = YuePuRunModelService.SolarEleMeter2.EleQ_N - SolarManageAnalyse.YearStartPointPw;

                if (_CurMinInfo != value)
                {
                    //DayChargPw = energyStorage.AcrelMeters.TotalInPWh - DayStartPointChargPw;
                    //DayDisChargPw = energyStorage.AcrelMeters.TotalOutPWh - DayStartPointDisChargPw;
                    _CurMinInfo = value;
                    //分钟改变和分钟数据为0那么需要触发小时保存数据
                    if (value == 59)
                    {
                        RecordYuPuHourData();
                    }
                }
            }
        }

        //private int _CurHourInfo;
        ///// <summary>
        ///// 当前的小时信息
        ///// 用户触发天的信息
        ///// </summary>
        //private int CurHourInfo
        //{
        //    get { return _CurHourInfo; }
        //    set
        //    {
        //        if (_CurHourInfo != value)
        //        {
        //            //小时改变和那么需要触发天的数据获取
        //            if (value == 0)
        //            {
        //                StartDayInfo();
        //            }
        //            _CurHourInfo = value;
        //        }
        //    }
        //}


        private int _CurDayInfo;
        /// <summary>
        /// 当前的天的信息
        /// </summary>
        private int CurDayInfo
        {
            get { return _CurDayInfo; }
            set
            {
                if (_CurDayInfo != value)
                {
                    var DayInitData = GetHistoryDataInfo(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0);
                    if (DayInitData != null)
                    {
                        //不为空的话，则赋值。获取本月第一个小时的数据作为本月的初始数据信息
                        EsManageAnalyse.DayStartPointChargPw = DayInitData.EsManageHourPointChargValue;
                        EsManageAnalyse.DayStartPointDisChargPw = DayInitData.EsManageHourPointDisChargValue;

                        SolarTaxAnalyse.DayStartPointPw = DayInitData.SolarTaxHourPointValue;
                        SolarManageAnalyse.DayStartPointPw = DayInitData.SolarManageHourPointValue;
                        
                    }
                    else
                    {
                        EsManageAnalyse.DayStartPointChargPw = GetEsAccChargPw();
                        EsManageAnalyse.DayStartPointDisChargPw = GetEsAccDisChargPw();

                        SolarTaxAnalyse.DayStartPointPw = YuePuRunModelService.SolarEleMeter3.EleQ_N;
                        SolarManageAnalyse.DayStartPointPw = YuePuRunModelService.SolarEleMeter2.EleQ_N;


                    }
                    _CurDayInfo = value;
                }
            }
        }

        private int _CurMonthInfo;
        /// <summary>
        /// 当前的月的信息
        /// </summary>
        private int CurMonthInfo
        {
            get { return _CurMonthInfo; }
            set
            {
                if (_CurMonthInfo != value)
                {
                    //月的改变和那么需要触月的数据获取
                    //需要获取当前月的第一天的数据信息
                    var MonthInitData = GetHistoryDataInfo(DateTime.Now.Year, DateTime.Now.Month, 1, 0);
                    if (MonthInitData != null)
                    {
                        //不为空的话，则赋值。获取本月第一个小时的数据作为本月的初始数据信息
                        EsManageAnalyse.MonthStartPointChargPw = MonthInitData.EsManageHourPointChargValue;
                        EsManageAnalyse.MonthStartPointDisChargPw = MonthInitData.EsManageHourPointDisChargValue;

                        SolarTaxAnalyse.MonthStartPointPw = MonthInitData.SolarTaxHourPointValue;
                        SolarManageAnalyse.MonthStartPointPw = MonthInitData.SolarManageHourPointValue;

                    }
                    else
                    {
                        EsManageAnalyse.MonthStartPointChargPw = GetEsAccChargPw();
                        EsManageAnalyse.MonthStartPointDisChargPw = GetEsAccDisChargPw();

                        SolarTaxAnalyse.MonthStartPointPw = YuePuRunModelService.SolarEleMeter3.EleQ_N;
                        SolarManageAnalyse.MonthStartPointPw = YuePuRunModelService.SolarEleMeter2.EleQ_N;
                    }
                    _CurMonthInfo = value;
                }
            }
        }


        private int _CurYearInfo;
        /// <summary>
        /// 当前的年的信息
        /// </summary>
        private int CurYearInfo
        {
            get { return _CurYearInfo; }
            set
            {
                if (_CurYearInfo != value)
                {
                    //var data = new DateTime(DateTime.Now.Year, 1, 1, 0, 0, 1).ToString("yyyy-MM-dd");

                    //需要获取当前年的第一天的数据信息
                    var YearInitData = GetHistoryDataInfo(DateTime.Now.Year, 1, 1, 0);
                    if (YearInitData != null)
                    {
                        //不为空的话，则赋值。获取新年第一个小时的数据作为本年的初始数据信息
                        EsManageAnalyse.YearStartPointChargPw = YearInitData.EsManageHourPointChargValue;
                        EsManageAnalyse.YearStartPointDisChargPw = YearInitData.EsManageHourPointDisChargValue;

                        SolarTaxAnalyse.YearStartPointPw = YearInitData.SolarTaxHourPointValue;
                        SolarManageAnalyse.YearStartPointPw = YearInitData.SolarManageHourPointValue;

                    }
                    else
                    {
                        EsManageAnalyse.YearStartPointChargPw = GetEsAccChargPw();
                        EsManageAnalyse.YearStartPointDisChargPw = GetEsAccDisChargPw();

                        SolarTaxAnalyse.YearStartPointPw = YuePuRunModelService.SolarEleMeter3.EleQ_N;
                        SolarManageAnalyse.YearStartPointPw = YuePuRunModelService.SolarEleMeter2.EleQ_N;
                    }

                    _CurYearInfo = value;
                }
            }
        }

        /// <summary>
        /// ConfigDbData Category数据
        /// </summary>
        private string Category { get; set; } = "PwAnalyze";


        #endregion

        /// <summary>
        /// 上个小时保存的数据
        /// 保存的上个小时的数据
        /// </summary>
        private YuPuHourData LastHourEnergyData { get; set; }

        private IFreeSql freeSql { get; set; }
        /// <summary>
        /// 当前的配置服务
        /// </summary>
        public ConfigDataService ConfigDataService { get; }
        //public SolarEnergyService SolarEnergyService { get; }
        public YuePuRunModelService YuePuRunModelService { get; }
        //public InPowerPCSDataService InPowerPCSDataService { get; }

        /// <summary>
        /// 记录小时数据
        /// </summary>
        private void RecordYuPuHourData()
        {
            try
            {
                var InsertData = freeSql.Insert<YuPuHourData>(new YuPuHourData()
                {
                    WorkDay = DateTime.Now.Day,
                    Month = DateTime.Now.Month,
                    Year = DateTime.Now.Year,
                    HourInfo = DateTime.Now.Hour,

                    //正向代表给储能充电
                    //反向代表储能给管理大楼放电
                    EsManageHourPointChargValue = GetEsAccChargPw(),
                    EsManageHourPointDisChargValue = GetEsAccDisChargPw(),
                    EsManageHourCharg = GetEsHourCharg(),
                    EsManageHourDisCharg = GetEsHourDisCharg(),


                    //反向代表光伏给税务大楼的供能
                    SolarTaxHourPointValue = YuePuRunModelService.SolarEleMeter3.EleQ_N,
                    SolarTaxHourCharg = GetSolarHour(),

                    SolarManageHourPointValue = YuePuRunModelService.SolarEleMeter2.EleQ_N,
                    SolarManageHourCharg = GetSolarToManageHour(),

                }).ExecuteInserted();

                Console.WriteLine($"{DateTime.Now.ToString()}：小时数据触发");
                //保存小时数据成功
                if (InsertData.Count > 0)
                {
                    LastHourEnergyData = InsertData.FirstOrDefault();
                    ListLastYuPuHourData = GetDayYuPuHourData();

                }
            }
            catch (Exception ex)
            {
                LogService.Info($"时间:{DateTime.Now.ToString()}-【RecordYuPuHourData】-{ex.Message}");
            }


        }

        /// <summary>
        /// 获取小时数据
        /// </summary>
        public ObservableCollection<YuPuHourData> GetDayYuPuHourData()
        {
            try
            {
                //获取最近12个小时的数据
                var Data = freeSql.Select<YuPuHourData>().OrderByDescending(a => a.CreateTime).Take(24).ToList();

                return new ObservableCollection<YuPuHourData>(Data);
            }
            catch (Exception ex)
            {
                LogService.Info($"时间:{DateTime.Now.ToString()}-【ExitPeakValley】-{ex.Message}");
                return new ObservableCollection<YuPuHourData>();
            }
        }

        /// <summary>
        /// 加载初始的数据
        /// </summary>
        /// <returns></returns>
        public void LoadInitialYuPuHourDataByDb()
        {
            //如果程序中间中断了一天，那么最新的作为上一个一个小时的数据，那么这个小时的数据会比较大，这个也没有问题，确保总数对的上即可。
            var FirstData = freeSql.Select<YuPuHourData>().OrderByDescending(a => a.CreateTime).Take(24).ToList();
            if (FirstData.Count > 0)
            {
                LastHourEnergyData = FirstData!.FirstOrDefault();
                ListLastYuPuHourData = new ObservableCollection<YuPuHourData>(FirstData);
            }
            else
            {
                LastHourEnergyData = new YuPuHourData();
            }
        }


        #region 统计信息

        /// <summary>
        /// 获取储能的总充电数据
        /// 取决于使用哪个数据仪表/PCS，封装成方法，方便替换
        /// </summary>
        /// <returns></returns>
        private double GetEsAccChargPw()
        {
            return YuePuRunModelService.EsEleMeter1.EleQ_P;
        }

        /// <summary>
        /// 获取储能的小时收益数据
        /// </summary>
        /// <returns></returns>
        private double GetEsHourRevenue(double price)
        {
            return (GetEsHourCharg() - GetEsHourDisCharg()) * price;
        }

        /// <summary>
        /// 获取储能的总放电数据
        /// 取决于使用哪个数据仪表/PCS，封装成方法，方便替换
        /// </summary>
        /// <returns></returns>
        private double GetEsAccDisChargPw()
        {
            return YuePuRunModelService.EsEleMeter1.EleQ_N;
        }

        /// <summary>
        /// 获取储能的充电小时数据
        /// </summary>
        /// <returns></returns>
        private double GetEsHourCharg()
        {
            return GetEsAccChargPw() - LastHourEnergyData.EsManageHourPointChargValue;
        }

        /// <summary>
        /// 获取储能的放电小时数据
        /// </summary>
        /// <returns></returns>
        private double GetEsHourDisCharg()
        {
            return GetEsAccDisChargPw() - LastHourEnergyData.EsManageHourPointDisChargValue;
        }

        /// <summary>
        /// 获取光伏的放电小时数据
        /// </summary>
        /// <returns></returns>
        private double GetSolarHour()
        {
            return YuePuRunModelService.SolarEleMeter3.EleQ_N - LastHourEnergyData.SolarTaxHourPointValue;

        }

        /// <summary>
        /// 获取光伏到管理大楼的放电小时数据
        /// </summary>
        /// <returns></returns>
        private double GetSolarToManageHour()
        {
            return YuePuRunModelService.SolarEleMeter2.EleQ_N - LastHourEnergyData.SolarManageHourPointValue;

        }

        ///// <summary>
        ///// 新的一年，年的初始信息
        ///// </summary>
        ///// <returns></returns>
        //private void LoadYearInit()
        //{
        //    //获取今年第一天的数据历史信息
        //    freeSql.Select<YuPuHourData>().Where(a => a.Year == DateTime.Now.Year && a.Month ==)

        //}

        /// <summary>
        /// 获取年月日的信息
        /// </summary>
        /// <returns></returns>
        private YuPuHourData GetHistoryDataInfo(int Year, int Month, int Day, int hour)
        {
            //获取今年第一天的数据历史信息
            var Data = freeSql.Select<YuPuHourData>().Where(a => a.Year == Year && a.Month == Month && a.WorkDay == Day && a.HourInfo == hour).ToList();
            if (Data.Count > 0)
            {
                return Data.FirstOrDefault();
            }

            return null;
        }


        /// <summary>
        /// 税务光伏统计模型
        /// </summary>
        public YuPuSolarTaxAnalyse SolarTaxAnalyse { get; set; } = new YuPuSolarTaxAnalyse();

        /// <summary>
        /// 管理大楼光伏统计模型
        /// </summary>
        public YuPuSolarManageAnalyse SolarManageAnalyse { get; set; } = new YuPuSolarManageAnalyse();
        
        /// <summary>
        /// 管理大楼储能统计模型
        /// </summary>
        public YuPuManageAnalyse EsManageAnalyse { get; set; } = new YuPuManageAnalyse();



        ///// <summary>
        ///// 液冷统计模型
        ///// </summary>
        //public CoolAnalyse CoolAnalyse { get; set; } = new CoolAnalyse();

        #endregion
    }

    public class YuPuManageAnalyse : BindableBase
    {
        /// <summary>
        /// 一天的开始0时充电量数据
        /// </summary>
        public double DayStartPointChargPw { get; set; }

        /// <summary>
        /// 一天的开始0时放电量数据
        /// </summary>
        public double DayStartPointDisChargPw { get; set; }


        /// <summary>
        /// 月度的开始1号充电量数据
        /// </summary>
        public double MonthStartPointChargPw { get; set; }

        /// <summary>
        /// 月度的开始1号充电量数据
        /// </summary>
        public double MonthStartPointDisChargPw { get; set; }


        /// <summary>
        /// 年的开始1号充电量数据
        /// </summary>
        public double YearStartPointChargPw { get; set; }

        /// <summary>
        /// 年的开始1号充电量数据
        /// </summary>
        public double YearStartPointDisChargPw { get; set; }




        /// <summary>
        /// ////////////////////////////////////储能充电量////////////////////////////////////////////
        /// </summary>


        private double _DayChargPw;
        /// <summary>
        /// 储能 日充电量 kWh
        /// </summary>
        public double DayChargPw
        {
            get { return _DayChargPw; }
            set { _DayChargPw = value; RaisePropertyChanged(); }
        }

        private double _MonthChargPw;
        /// <summary>
        /// 储能 月充电量 kWh
        /// </summary>
        public double MonthChargPw
        {
            get { return _MonthChargPw; }
            set { _MonthChargPw = value; RaisePropertyChanged(); }
        }

        private double _YearChargPw;
        /// <summary>
        /// 储能 年充电量 kWh
        /// </summary>
        public double YearChargPw
        {
            get { return _YearChargPw; }
            set { _YearChargPw = value; RaisePropertyChanged(); }
        }

        private double _TotalChargPw;
        /// <summary>
        /// 储能 总充电量 kWh
        /// </summary>
        public double TotalChargPw
        {
            get { return _TotalChargPw; }
            set { _TotalChargPw = value; RaisePropertyChanged(); }
        }


        /// <summary>
        /// ////////////////////////////////////储能放电量////////////////////////////////////////////
        /// </summary>


        private double _DayDisChargPw;
        /// <summary>
        /// 储能 日放电量 kWh
        /// </summary>
        public double DayDisChargPw
        {
            get { return _DayDisChargPw; }
            set { _DayDisChargPw = value; RaisePropertyChanged(); }
        }

        private double _MonthDisChargPw;
        /// <summary>
        /// 储能 月放电量 kWh
        /// </summary>
        public double MonthDisChargPw
        {
            get { return _MonthDisChargPw; }
            set { _MonthDisChargPw = value; RaisePropertyChanged(); }
        }

        private double _YearDisChargPw;
        /// <summary>
        /// 储能 年放电量 kWh
        /// </summary>
        public double YearDisChargPw
        {
            get { return _YearDisChargPw; }
            set { _YearDisChargPw = value; RaisePropertyChanged(); }
        }

        private double _TotalDisChargPw;
        /// <summary>
        /// 储能 总放电量 kWh
        /// </summary>
        public double TotalDisChargPw
        {
            get { return _TotalDisChargPw; }
            set { _TotalDisChargPw = value; RaisePropertyChanged(); }
        }
    }

    /// <summary>
    /// 光伏税务
    /// </summary>
    public class YuPuSolarTaxAnalyse : BindableBase
    {
        /// <summary>
        /// 一天的开始0时发电量数据
        /// </summary>
        public double DayStartPointPw { get; set; }

        /// <summary>
        /// 月份的开始0时发电量数据
        /// </summary>
        public double MonthStartPointPw { get; set; }

        /// <summary>
        /// 年的开始0时发电量数据
        /// </summary>
        public double YearStartPointPw { get; set; }


        private double _DayChargPw;
        /// <summary>
        /// 光伏 光伏日发电量 kWh
        /// </summary>
        public double DayChargPw
        {
            get { return _DayChargPw; }
            set { _DayChargPw = value; RaisePropertyChanged(); }
        }

        private double _MonthChargPw;
        /// <summary>
        /// 光伏 光伏月发电量 kWh
        /// </summary>
        public double MonthChargPw
        {
            get { return _MonthChargPw; }
            set { _MonthChargPw = value; RaisePropertyChanged(); }
        }

        private double _YearChargPw;
        /// <summary>
        /// 光伏 光伏年发电量 kWh
        /// </summary>
        public double YearChargPw
        {
            get { return _YearChargPw; }
            set { _YearChargPw = value; RaisePropertyChanged(); }
        }

        private double _TotalChargPw;
        /// <summary>
        /// 光伏 光伏总发电量 kWh
        /// </summary>
        public double TotalChargPw
        {
            get { return _TotalChargPw; }
            set { _TotalChargPw = value; RaisePropertyChanged(); }
        }
    }


    /// <summary>
    /// 光伏管理大楼
    /// </summary>
    public class YuPuSolarManageAnalyse : BindableBase
    {
        /// <summary>
        /// 一天的开始0时发电量数据
        /// </summary>
        public double DayStartPointPw { get; set; }

        /// <summary>
        /// 月份的开始0时发电量数据
        /// </summary>
        public double MonthStartPointPw { get; set; }

        /// <summary>
        /// 年的开始0时发电量数据
        /// </summary>
        public double YearStartPointPw { get; set; }


        private double _DayChargPw;
        /// <summary>
        /// 光伏 光伏日发电量 kWh
        /// </summary>
        public double DayChargPw
        {
            get { return _DayChargPw; }
            set { _DayChargPw = value; RaisePropertyChanged(); }
        }

        private double _MonthChargPw;
        /// <summary>
        /// 光伏 光伏月发电量 kWh
        /// </summary>
        public double MonthChargPw
        {
            get { return _MonthChargPw; }
            set { _MonthChargPw = value; RaisePropertyChanged(); }
        }

        private double _YearChargPw;
        /// <summary>
        /// 光伏 光伏年发电量 kWh
        /// </summary>
        public double YearChargPw
        {
            get { return _YearChargPw; }
            set { _YearChargPw = value; RaisePropertyChanged(); }
        }

        private double _TotalChargPw;
        /// <summary>
        /// 光伏 光伏总发电量 kWh
        /// </summary>
        public double TotalChargPw
        {
            get { return _TotalChargPw; }
            set { _TotalChargPw = value; RaisePropertyChanged(); }
        }
    }
}