using System;
using System.Collections.Generic;
using Thermo.Active.Database.Redis;
using Thermo.Active.Model.DTOModels;
using Thermo.Active.Model.DTOModels.ThAxes;

namespace Thermo.Active.Database.Controllers
{
    public static class RedisController
    {
        private const string redisNotificationAddress = "Machine:ProductionProcesses:%NN%:Notification";
        private const string redisProdNameAddress = "Machine:ProductionProcesses:%NN%:Programs:01:Name";
        private const string redisRepsTargetAddress = "Machine:ProductionProcesses:%NN%:Programs:01:RepsTarget";
        private const string redisRepsDoneAddress = "Machine:ProductionProcesses:%NN%:Programs:01:RepsDone";
        private const string redisAlmCurr = "AdpConf:Plc:Condition:Curr";
        private const string redisAlmIt = "AdpConf:Plc:Condition:It";
        private const string redisAlmEn = "AdpConf:Plc:Condition:En";
        private const string currentUserPath = "Machine:Hmi:User";
        private const string machineStatusPath = "Machine:Status";
        private const string machinePowerPath = "Machine:Power";
        private const string machineAlarmPath = "Machine:Alarm";
        private const string machineEmergencyPath = "Machine:Emergency";
        private const string alarmsPath = "Machine:Plc:Condition";
        private const string processStatusPath = "Machine:Cnc:CncProcesses:%NN%:Status";
        private const string processModePath = "Machine:Cnc:CncProcesses:%NN%:Mode";
        private const string processFeedOverridePath = "Machine:Cnc:CncProcesses:%NN%:FeedOverride";
        private const string processRapidOverridePath = "Machine:Cnc:CncProcesses:%NN%:RapidOverride";
        private const string processSpeedOverridePath = "Machine:Cnc:CncProcesses:%NN%:SpeedOverride";

        private const string datamodelPath = "AdpConf:DataModel";
        private const string currentActiveVersionPath = "Machine:Hmi:Version";
        private const string machineAxisPosition = "Machine:Axes:%NN%:CurrentPos";
        private const string machineAxisSpeed = "Machine:Axes:%NN%:FeedRate";
        private const string machineAxisLoad = "Machine:Axes:%NN%:Load";
        private const string machineAxisName = "Machine:Axes:%NN%:Name";
        private const string machineEventKpis = "Events:Kpis";
        private const string machineMessagePath = "Events:Messages";

        public static void WriteProductionNotification(uint ProductionProcess, string Notification)
        {
            string redisHash = redUtil.man.redHash(redisNotificationAddress).Replace("%NN%", ProductionProcess.ToString("00"));
            redUtil.man.setRSV(redisHash, Notification);
        }

        public static void WriteProductionName(uint ProductionProcess, string Name)
        {
            string redisHash = redUtil.man.redHash(redisProdNameAddress).Replace("%NN%", ProductionProcess.ToString("00"));
            redUtil.man.setRSV(redisHash, Name);
        }

        public static void WriteProductionRepsTarget(uint ProductionProcess, string RepsTarget)
        {
            string redisHash = redUtil.man.redHash(redisRepsTargetAddress).Replace("%NN%", ProductionProcess.ToString("00"));
            redUtil.man.setRSV(redisHash, RepsTarget);
        }

        public static void WriteProductionRepsDone(uint ProductionProcess, string RepsDone)
        {
            string redisHash = redUtil.man.redHash(redisRepsDoneAddress).Replace("%NN%", ProductionProcess.ToString("00"));
            redUtil.man.setRSV(redisHash, RepsDone);
        }

        public static bool WriteAlarmsConfigCurr(Dictionary<string, string> alarms)
        {
            string redisHash = redUtil.man.redHash(redisAlmCurr);
            return redUtil.man.redSaveHashDict(redisHash, alarms);
        }

        public static bool WriteAlarmsConfigEn(Dictionary<string, string> alarms)
        {
            string redisHash = redUtil.man.redHash(redisAlmEn);
            return redUtil.man.redSaveHashDict(redisHash, alarms);
        }


        public static bool WriteDatamodel(string datamodel)
        {
            string redisHash = redUtil.man.redHash(datamodelPath);
            return redUtil.man.setRSV(redisHash, datamodel.ToString());
        }
        public static bool WriteDefaultEntry(Dictionary<string, string> entries)
        {
            foreach (KeyValuePair<string, string> entry in entries)
            {
                if (!redUtil.man.setRSV(redUtil.man.redHash(entry.Key), entry.Value))
                    return false;
            }
            return true;
        }

        public static bool WriteAlarmsConfigIt(Dictionary<string, string> alarms)
        {
            string redisHash = redUtil.man.redHash(redisAlmIt);
            return redUtil.man.redSaveHashDict(redisHash, alarms);
        }

        public static bool WriteCurrentUser(string User)
        {
            string redisHash = redUtil.man.redHash(currentUserPath);
            return redUtil.man.setRSV(redisHash, User.ToString());
        }
        public static bool WriteActiveVersion(string version)
        {
            string redisHash = redUtil.man.redHash(currentActiveVersionPath);
            return redUtil.man.setRSV(redisHash, version.ToString());
        }

        public static bool WriteCurrentMachineStatus(string status)
        {
            string redisHash = redUtil.man.redHash(machineStatusPath);
            return redUtil.man.setRSV(redisHash, status.ToString());
        }

        public static bool WriteCurrentProcessStatus(uint ProductionProcess, string status)
        {
            string redisHash = redUtil.man.redHash(processStatusPath).Replace("%NN%", ProductionProcess.ToString("00"));
            return redUtil.man.setRSV(redisHash, status.ToString());
        }

        public static bool WriteCurrentProcessMode(uint ProductionProcess, string status)
        {
            string redisHash = redUtil.man.redHash(processModePath).Replace("%NN%", ProductionProcess.ToString("00"));
            return redUtil.man.setRSV(redisHash, status.ToString());
        }

        public static bool WriteFakeOverrides(uint ProductionProcess)
        {
            string redisHash = redUtil.man.redHash(processFeedOverridePath).Replace("%NN%", ProductionProcess.ToString("00"));
            if (!redUtil.man.setRSV(redisHash, "100"))
                return false;
            redisHash = redUtil.man.redHash(processRapidOverridePath).Replace("%NN%", ProductionProcess.ToString("00"));
            if (!redUtil.man.setRSV(redisHash, "100"))
                return false;
            redisHash = redUtil.man.redHash(processSpeedOverridePath).Replace("%NN%", ProductionProcess.ToString("00"));
            if (!redUtil.man.setRSV(redisHash, "100"))
                return false;
            return true;
        }


        public static bool WriteCurrentMachinePowerPath(bool status)
        {
            string redisHash = redUtil.man.redHash(machinePowerPath);
            if (status)
                return redUtil.man.setRSV(redisHash, "true");
            else
                return redUtil.man.setRSV(redisHash, "false");
        }

        public static bool WriteCurrentMachineAlarmPath(bool status)
        {
            string redisHash = redUtil.man.redHash(machineAlarmPath);
            if (status)
                return redUtil.man.setRSV(redisHash, "true");
            else
                return redUtil.man.setRSV(redisHash, "false");
        }

        public static bool WriteCurrentMachineEmergencyPath(bool status)
        {
            string redisHash = redUtil.man.redHash(machineEmergencyPath);
            if (status)
                return redUtil.man.setRSV(redisHash, "true");
            else
                return redUtil.man.setRSV(redisHash, "false");
        }

        public static bool WriteCurrentAlarms(string alarms)
        {
            string redisHash = redUtil.man.redHash(alarmsPath);
            return redUtil.man.setRSV(redisHash, alarms);
        }

        public static bool WriteMachineEventKpis(string alarms)
        {
            string redisHash = redUtil.man.redHash(machineEventKpis);
            redUtil.man.ListPush(redisHash, alarms);
            return true;
        }

        public static bool SendMessage(string msg)
        {
            string redisHash = redUtil.man.redHash(machineMessagePath);
            redUtil.man.ListPush(redisHash, msg);
            return true;
        }
        public static string ReadValue(string msgKey)
        {
            string redisHash = redUtil.man.redHash(msgKey);
            return redUtil.man.getRSV(redisHash);
        }
        public static bool WriteValue(string msgKey, string msg, int ttlSec)
        {
            string redisHash = redUtil.man.redHash(msgKey);
            redUtil.man.setRSV(redisHash, msg, ttlSec);
            return true;
        }

        public static bool FastIoSample
        {
            get
            {
                var currVal = ReadValue("FastIoSample");
                bool answ = !string.IsNullOrEmpty(currVal);
                return answ;
            }
            set
            {
                // TTL: se true 20 min, altrimenti 1 sec
                int ttlSec = value ? 60 * 20 : 1;
                WriteValue("FastIoSample", "Active", ttlSec);
            }
        }

        public static DateTime SetFastIoSample(bool value)
        {
            // TTL: se true 20 min, altrimenti 1 sec
            int ttlSec = value ? 60 * 20 : 1;
            WriteValue("FastIoSample", "Active", ttlSec);
            return DateTime.Now.AddSeconds(ttlSec);
        }



        public static bool WriteCurrentAxisStatus(Dictionary<int, DTOAxisInfoModel> axis)
        {
            foreach (KeyValuePair<int, DTOAxisInfoModel> asse in axis)
            {
                string redisHash = redUtil.man.redHash(machineAxisName).Replace("%NN%", asse.Value.ID.ToString("00"));

                if (redUtil.man.getRSV(redisHash) != null)
                {
                    redisHash = redUtil.man.redHash(machineAxisPosition).Replace("%NN%", asse.Value.ID.ToString("00"));
                    if (!redUtil.man.setRSV(redisHash, asse.Value.position.ToString()))
                        return false;

                    redisHash = redUtil.man.redHash(machineAxisSpeed).Replace("%NN%", asse.Value.ID.ToString("00"));
                    if (!redUtil.man.setRSV(redisHash, asse.Value.speed.ToString()))
                        return false;

                    redisHash = redUtil.man.redHash(machineAxisLoad).Replace("%NN%", asse.Value.ID.ToString("00"));
                    if (!redUtil.man.setRSV(redisHash, asse.Value.load.ToString()))
                        return false;
                }
            }
            return true;
        }

    }
}