using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using System.Text.RegularExpressions;
using vnxbqy.UI;

using LitJson;

public class DailyQuestData
{
    public int id { get; private set; }
    public Redpoint redpoint { get; private set; }

    public DailyQuestData(int _id)
    {
        this.id = _id;
    }

    public DailyQuestData(int _id, int _redpointId, int _parentRedpoint)
    {
        this.id = _id;
        this.redpoint = new Redpoint(_parentRedpoint, _redpointId);
    }

    public void UpdateRedpointState(RedPointState _redpointState)
    {
        if (this.redpoint != null)
        {
            this.redpoint.state = _redpointState;
        }
    }

}

public class DailyQuestActiveValueReward
{
    public int id { get; private set; }

    bool m_Got = false;
    public bool got {
        get { return this.m_Got; }
        set { this.m_Got = value; }
    }

    public DailyQuestActiveValueReward(int _id)
    {
        this.id = _id;
    }
}

public struct DailyQuestTimes
{
    public int completeTimes;
    public int dayBuyTimes;
    public int dayUseItemTimes;
}

public class DailyQuestOpenTime
{
    public int id;
    public bool always;

    //常规的活动时间，key是星期x
    Dictionary<int, List<HourMinute>> openTimes = new Dictionary<int, List<HourMinute>>();
    public Dictionary<int, List<HourMinute>> NormalOpenTimes { get { return openTimes; } }
    //开服前2周的活动时间,key1是开服日的星期，key2是开服第几天
    Dictionary<int, Dictionary<int, List<HourMinute>>> specialOpenTimes = new Dictionary<int, Dictionary<int, List<HourMinute>>>();
    //合服之后的活动时间，key是第几天
    Dictionary<int, List<HourMinute>> mixServerOpenTimes = new Dictionary<int, List<HourMinute>>();

    public DailyQuestOpenTime(int _id)
    {
        this.id = _id;
    }

    public void ParseQuestNormalOpenTime(DailyQuestOpenTimeConfig activityOpenTime)
    {
        string timeString = activityOpenTime.OpenTime;
        int duration = activityOpenTime.Duration;
        var matches = Regex.Matches(timeString, "\\\"[0-9]\\\":\\[[0-9|,|\\[|\\]]+");
        always = matches.Count == 0;

        for (int i = 0; i < matches.Count; i++)
        {
            var match = matches[i];
            var stringArray = match.Value.Split(':');

            var week = 0;
            var weekMatch = Regex.Match(stringArray[0], "[0-9]");
            int.TryParse(weekMatch.Value, out week);

            if (week == 0)
            {
                var subMatches = Regex.Matches(stringArray[1], "[0-9]{1,2},[0-9]{1,2}");
                var tempHourMinutes = new List<HourMinute>();

                for (int j = 0; j < subMatches.Count; j++)
                {
                    tempHourMinutes.Add(new HourMinute(subMatches[j].Value, duration));
                }

                tempHourMinutes.Sort((HourMinute a, HourMinute b) => { return HourMinute.Compare(a, b); });

                for (int j = 0; j < 7; j++)
                {
                    var hourMinutes = openTimes[j] = new List<HourMinute>(tempHourMinutes);
                }
            }
            else
            {
                var hourMinutes = openTimes[week % 7] = new List<HourMinute>();
                var subMatches = Regex.Matches(stringArray[1], "[0-9]{1,2},[0-9]{1,2}");

                for (int j = 0; j < subMatches.Count; j++)
                {
                    hourMinutes.Add(new HourMinute(subMatches[j].Value, duration));
                }

                hourMinutes.Sort((HourMinute a, HourMinute b) => { return HourMinute.Compare(a, b); });
            }
        }
    }

    public void ParseQuestSpecialOpenTimes(List<DailyQuestSpecialOpenTimeConfig> configs)
    {
        if (configs == null)
        {
            return;
        }

        foreach (var config in configs)
        {
            var openDayWeek = config.OpenServerWeek % 7;
            if (!specialOpenTimes.ContainsKey(openDayWeek))
            {
                specialOpenTimes[openDayWeek] = new Dictionary<int, List<HourMinute>>();
            }

            var dayIndexOpenTimes = specialOpenTimes[openDayWeek];
            var dayIndex = config.OpenServerDay;
            if (!dayIndexOpenTimes.ContainsKey(dayIndex))
            {
                dayIndexOpenTimes[dayIndex] = new List<HourMinute>();
            }

            var matches = Regex.Matches(config.TimeList, "\\[[0-9]{1,2},[0-9]{1,2}\\]");
            var hourMinutes = dayIndexOpenTimes[dayIndex];

            for (int i = 0; i < matches.Count; i++)
            {
                var temp = matches[i].Value;
                hourMinutes.Add(new HourMinute(temp, config.Duration));
            }
        }
    }

    public void ParseQuestMixServerOpenTime(List<DailyQuestMixServerStateTimeConfig> configs)
    {
        if (configs == null)
        {
            return;
        }

        foreach (var config in configs)
        {
            var timeString = config.TimeList;
            var duration = config.Duration;

            List<HourMinute> hourMinutes = null;
            if (mixServerOpenTimes.ContainsKey(config.MixServerDay))
            {
                hourMinutes = mixServerOpenTimes[config.MixServerDay];
            }
            else
            {
                hourMinutes = mixServerOpenTimes[config.MixServerDay] = new List<HourMinute>();
            }

            var matches = Regex.Matches(timeString, "[0-9]{1,2},[0-9]{1,2}");
            for (var i = 0; i < matches.Count; i++)
            {
                hourMinutes.Add(new HourMinute(matches[i].Value, duration));
            }

        }
    }

    public void ParseDungeonNormalOpenTimes(List<DungeonStateTimeConfig> configs)
    {
        always = configs == null || configs.Count == 0;

        if (!always)
        {
            for (int i = 0; i < configs.Count; i++)
            {
                var config = configs[i];
                if (config.CanEnter == 0)
                {
                    continue;
                }

                if (config.StartWeekday == 0 && config.EndWeekday == 0)
                {
                    for (int j = 0; j < 7; j++)
                    {
                        if (!openTimes.ContainsKey(j))
                        {
                            openTimes[j] = new List<HourMinute>();
                        }
                        var hourMinutes = openTimes[j];
                        hourMinutes.Add(new HourMinute(config.StartHour, config.StartMinute, config.EndHour, config.EndMinute));
                    }
                }
                else
                {
                    var dayOfWeek = config.StartWeekday % 7;
                    if (!openTimes.ContainsKey(dayOfWeek))
                    {
                        openTimes[dayOfWeek] = new List<HourMinute>();
                    }

                    var hourMinutes = openTimes[dayOfWeek];
                    hourMinutes.Add(new HourMinute(config.StartHour, config.StartMinute, config.EndHour, config.EndMinute));
                }
            }
        }
    }

    public void ParseDungeonSpecialOpenTimes(List<DungeonSpecialStateTimeConfig> configs)
    {
        if (configs == null)
        {
            return;
        }

        foreach (var config in configs)
        {
            if (config.CanEnter == 0)
            {
                continue;
            }

            var openDayWeek = config.OpenServerWeek % 7;
            if (!specialOpenTimes.ContainsKey(openDayWeek))
            {
                specialOpenTimes[openDayWeek] = new Dictionary<int, List<HourMinute>>();
            }

            var dayIndexOpenTimes = specialOpenTimes[openDayWeek];
            var dayIndex = config.OpenServerDay;
            if (!dayIndexOpenTimes.ContainsKey(dayIndex))
            {
                dayIndexOpenTimes[dayIndex] = new List<HourMinute>();
            }

            var hourMinutes = dayIndexOpenTimes[dayIndex];
            hourMinutes.Add(new HourMinute(config.StartHour, config.StartMinute, config.EndHour, config.EndMinute));

        }
    }

    public void ParseDungeonMixServerOpenTimes(List<DungeonMixServerStateTimeConfig> configs)
    {
        if (configs == null)
        {
            return;
        }

        foreach (var config in configs)
        {
            if (config.CanEnter == 0)
            {
                continue;
            }

            List<HourMinute> hourMinutes = null;
            if (mixServerOpenTimes.ContainsKey(config.MixServerDay))
            {
                hourMinutes = mixServerOpenTimes[config.MixServerDay];
            }
            else
            {
                hourMinutes = mixServerOpenTimes[config.MixServerDay] = new List<HourMinute>();
            }

            hourMinutes.Add(new HourMinute(config.StartHour, config.StartMinute, config.EndHour, config.EndMinute));
        }

    }

    public bool IsValidServerOpenTime()
    {
        return true;
    }



    // 改成判断日常活动ID不在定制中配置则定制期间正常开启
    public bool InOpenTime()
    {
        if (always)
        {
            return true;
        }

        var isMixServer = TimeUtility.IsMixServer && TimeUtility.MixOpenDay < GeneralDefine.mixServerCustomDays;
        if (isMixServer && mixServerOpenTimes.Count > 0)
        {
            var dayIndex = TimeUtility.MixOpenDay + 1;
            if (!mixServerOpenTimes.ContainsKey(dayIndex))
            {
                return false;
            }
            else
            {
                var hourMinutes = mixServerOpenTimes[dayIndex];
                foreach (var item in hourMinutes)
                {
                    if (item.InOpenTime())
                    {
                        return true;
                    }
                }

                return false;
            }
        }
        else
        {
            var isSpecialDay = TimeUtility.OpenDay < 7 && (DailyQuestType)id != DailyQuestType.CrossServerPk 
                && (DailyQuestType)id != DailyQuestType.default4;
            var openDayWeek = (int)TimeUtility.openServerDayOfWeek;
            var dayIndex = TimeUtility.OpenDay + 1;
            if (isSpecialDay && specialOpenTimes.Count > 0)
            {
                if (specialOpenTimes.ContainsKey(openDayWeek) && specialOpenTimes[openDayWeek].ContainsKey(dayIndex))
                {
                    var hourMinutes = specialOpenTimes[openDayWeek][dayIndex];
                    for (int i = 0; i < hourMinutes.Count; i++)
                    {
                        if (hourMinutes[i].InOpenTime())
                        {
                            return true;
                        }
                    }

                    return false;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return IsNormalOpenTime();
            }
        }

    }

    //日常活动开启判断
    private bool IsNormalOpenTime()
    {
        var dayOfWeek = (int)TimeUtility.ServerNow.DayOfWeek;
        if (!openTimes.ContainsKey(dayOfWeek))
        {
            return false;
        }
        else
        {
            var hourMinutes = openTimes[dayOfWeek];
            for (int i = 0; i < hourMinutes.Count; i++)
            {
                if (hourMinutes[i].InOpenTime())
                {
                    return true;
                }
            }

            return false;
        }
    }


    public bool TryGetTodayNearestOpenTime(out HourMinute _hourMinute)
    {
        var isMixServer = TimeUtility.IsMixServer && TimeUtility.MixOpenDay < GeneralDefine.mixServerCustomDays;
        if (isMixServer && mixServerOpenTimes.Count > 0)
        {
            var dayIndex = TimeUtility.MixOpenDay + 1;
            if (!mixServerOpenTimes.ContainsKey(dayIndex))
            {
                _hourMinute = default(HourMinute);
                return false;
            }
            else
            {
                var hour = TimeUtility.ServerNow.Hour;
                var minute = TimeUtility.ServerNow.Minute;
                var hourMinutes = mixServerOpenTimes[dayIndex];
                _hourMinute = hourMinutes[hourMinutes.Count - 1];
                foreach (var hourMinute in hourMinutes)
                {
                    if (hour < hourMinute.hourEnd || (hour == hourMinute.hourEnd && minute <= hourMinute.minuteEnd))
                    {
                        _hourMinute = hourMinute;
                        break;
                    }
                }

                return true;
            }
        }
        else
        {
            var isSpecialDay = TimeUtility.OpenDay < 7 && (DailyQuestType)id != DailyQuestType.CrossServerPk
                && (DailyQuestType)id != DailyQuestType.default4;
            var openDayWeek = (int)TimeUtility.openServerDayOfWeek;
            var dayIndex = TimeUtility.OpenDay + 1;
            if (isSpecialDay && specialOpenTimes.Count > 0)
            {
                if (specialOpenTimes.ContainsKey(openDayWeek) && specialOpenTimes[openDayWeek].ContainsKey(dayIndex))
                {
                    var hour = TimeUtility.ServerNow.Hour;
                    var minute = TimeUtility.ServerNow.Minute;
                    var hourMinutes = specialOpenTimes[openDayWeek][dayIndex];
                    _hourMinute = hourMinutes[hourMinutes.Count - 1];
                    for (int i = 0; i < hourMinutes.Count; i++)
                    {
                        var hourMinute = hourMinutes[i];
                        if (hour < hourMinute.hourEnd || (hour == hourMinute.hourEnd && minute <= hourMinute.minuteEnd))
                        {
                            _hourMinute = hourMinute;
                            break;
                        }
                    }

                    return true;
                }
                else
                {
                    _hourMinute = default(HourMinute);
                    return false;
                }
            }
            else
            {
                var dayOfWeek = (int)TimeUtility.ServerNow.DayOfWeek;
                if (!openTimes.ContainsKey(dayOfWeek))
                {
                    _hourMinute = default(HourMinute);
                    return false;
                }

                var hour = TimeUtility.ServerNow.Hour;
                var minute = TimeUtility.ServerNow.Minute;
                var hourMinutes = openTimes[dayOfWeek];
                _hourMinute = hourMinutes[hourMinutes.Count - 1];
                for (int i = 0; i < hourMinutes.Count; i++)
                {
                    var hourMinute = hourMinutes[i];
                    if (hour < hourMinute.hourEnd || (hour == hourMinute.hourEnd && minute <= hourMinute.minuteEnd))
                    {
                        _hourMinute = hourMinute;
                        break;
                    }
                }

                return true;
            }
        }

    }

    public bool TryGetNextOpenTime(out HourMinute _hourMinute)
    {
        _hourMinute = default(HourMinute);

        var openDayWeek = (int)TimeUtility.openServerDayOfWeek;
        var dayIndex = TimeUtility.OpenDay + 1;
        var maxSpecialDays = GeneralDefine.mixServerCustomDays + 1 - (openDayWeek == 0 ? 7 : openDayWeek);
        var hour = TimeUtility.ServerNow.Hour;
        var minute = TimeUtility.ServerNow.Minute;
        var mixDayIndex = 0;
        for (int i = 0; i <= 7; i++)//一周内必须有活动
        {
            List<HourMinute> hourminutes = null;
            var days = dayIndex + i;
            if (mixServerOpenTimes.Count > 0 && IsInMixServerCustomDay(days, out mixDayIndex))
            {
                if (!mixServerOpenTimes.ContainsKey(mixDayIndex))
                {
                    continue;
                }
                hourminutes = mixServerOpenTimes[mixDayIndex];
            }
            else if (specialOpenTimes.Count > 0 && days <= maxSpecialDays)
            {
                if (!specialOpenTimes.ContainsKey(openDayWeek)
                || !specialOpenTimes[openDayWeek].ContainsKey(days))
                {
                    continue;
                }
                hourminutes = specialOpenTimes[openDayWeek][days];
            }
            else
            {
                var dayOfWeek = (int)TimeUtility.ServerNow.AddTicks(i * TimeSpan.TicksPerDay).DayOfWeek;
                if (!openTimes.ContainsKey(dayOfWeek))
                {
                    continue;
                }
                hourminutes = openTimes[dayOfWeek];
            }
            if (hourminutes != null)
            {
                foreach (var hourMinute in hourminutes)
                {
                    if (days == dayIndex && hourMinute.AfterOpenTime(hour, minute))
                    {
                        continue;
                    }
                    _hourMinute = hourMinute;
                    return true;
                }
            }
        }
        return false;
    }

    bool IsInMixServerCustomDay(int day, out int index)
    {
        index = -1;

        if (!TimeUtility.IsMixServer)
        {
            return false;
        }

        var openServerDate = TimeUtility.ServerNow.AddTicks(-TimeUtility.OpenDay * TimeSpan.TicksPerDay);
        openServerDate = new DateTime(openServerDate.Year, openServerDate.Month, openServerDate.Day);

        var mixServerOpenDate = TimeUtility.ServerNow.AddTicks(-TimeUtility.MixOpenDay * TimeSpan.TicksPerDay);
        mixServerOpenDate = new DateTime(mixServerOpenDate.Year, mixServerOpenDate.Month, mixServerOpenDate.Day);

        var offset = (int)(mixServerOpenDate - openServerDate).TotalDays;
        index = day - offset;
        return index <= GeneralDefine.mixServerCustomDays;
    }

    public int GetNextSessionSurplusTime()
    {
        if (InOpenTime())
        {
            return 0;
        }
        var openDayWeek = (int)TimeUtility.openServerDayOfWeek;
        var dayIndex = TimeUtility.OpenDay + 1;
        var maxSpecialDays = GeneralDefine.mixServerCustomDays + 1 - (openDayWeek == 0 ? 7 : openDayWeek);
        var hour = TimeUtility.ServerNow.Hour;
        var minute = TimeUtility.ServerNow.Minute;
        var mixDayIndex = 0;
        for (int i = 0; i <= 7; i++)//一周内必须有活动
        {
            List<HourMinute> hourminutes = null;
            var days = dayIndex + i;
            if (mixServerOpenTimes.Count > 0 && IsInMixServerCustomDay(days, out mixDayIndex))
            {
                if (!mixServerOpenTimes.ContainsKey(mixDayIndex))
                {
                    continue;
                }
                hourminutes = mixServerOpenTimes[mixDayIndex];
            }
            else if (specialOpenTimes.Count > 0 && days <= maxSpecialDays)
            {
                if (!specialOpenTimes.ContainsKey(openDayWeek)
                || !specialOpenTimes[openDayWeek].ContainsKey(days))
                {
                    continue;
                }
                hourminutes = specialOpenTimes[openDayWeek][days];
            }
            else
            {
                var dayOfWeek = (int)TimeUtility.ServerNow.AddTicks(i * TimeSpan.TicksPerDay).DayOfWeek;
                if (!openTimes.ContainsKey(dayOfWeek))
                {
                    continue;
                }
                hourminutes = openTimes[dayOfWeek];
            }
            if (hourminutes != null)
            {
                foreach (var hourMinute in hourminutes)
                {
                    if (days == dayIndex && hourMinute.AfterOpenTime(hour, minute))
                    {
                        continue;
                    }
                    var time = TimeUtility.ServerNow.AddTicks(i * TimeSpan.TicksPerDay);
                    time = new DateTime(time.Year, time.Month, time.Day, hourMinute.hourBegin, hourMinute.minuteBegin, 0);
                    var seconds = (int)(time - TimeUtility.ServerNow).TotalSeconds;
                    return Mathf.Max(0, seconds);
                }
            }
        }
        return 0;
    }

    public int PassSessionCount(DateTime beginTime)
    {
        var openDayWeek = (int)TimeUtility.openServerDayOfWeek;
        var dayIndex = TimeUtility.OpenDay + 1;
        var maxSpecialDays = GeneralDefine.mixServerCustomDays + 1 - (openDayWeek == 0 ? 7 : openDayWeek);
        var beginHour = beginTime.Hour;
        var beginMinute = beginTime.Minute;
        var session = 0;
        var mixDayIndex = 0;

        var openServerDay = TimeUtility.ServerNow.AddTicks(-TimeUtility.OpenDay * TimeSpan.TicksPerDay);
        openServerDay = new DateTime(openServerDay.Year, openServerDay.Month, openServerDay.Day);
        var beginDay = (int)(beginTime - openServerDay).TotalDays + 1;
        List<HourMinute> hourMinutes = null;

        if (mixServerOpenTimes.Count > 0 && IsInMixServerCustomDay(beginDay, out mixDayIndex))
        {
            if (mixServerOpenTimes.ContainsKey(mixDayIndex))
            {
                hourMinutes = mixServerOpenTimes[mixDayIndex];
            }
        }
        else if (specialOpenTimes.Count > 0 && beginDay <= maxSpecialDays)
        {
            if (specialOpenTimes.ContainsKey(openDayWeek) && specialOpenTimes[openDayWeek].ContainsKey(beginDay))
            {
                hourMinutes = specialOpenTimes[openDayWeek][beginDay];
            }
        }
        else
        {
            var dayOfWeek = (int)beginTime.DayOfWeek;
            if (openTimes.ContainsKey(dayOfWeek))
            {
                hourMinutes = openTimes[dayOfWeek];
            }
        }
        if (hourMinutes != null)
        {
            var hourMinute = hourMinutes[hourMinutes.Count - 1];
            if (hourMinute.AfterOpenTime(beginHour, beginMinute))
            {
                beginDay++;
            }
        }

        var nowHour = TimeUtility.ServerNow.Hour;
        var nowMinute = TimeUtility.ServerNow.Minute;
        for (int i = beginDay; i <= dayIndex; i++)
        {
            hourMinutes = null;
            if (mixServerOpenTimes.Count > 0 && IsInMixServerCustomDay(i, out mixDayIndex))
            {
                if (mixServerOpenTimes.ContainsKey(mixDayIndex))
                {
                    hourMinutes = mixServerOpenTimes[mixDayIndex];
                }
            }
            else if (specialOpenTimes.Count > 0 && i <= maxSpecialDays)
            {
                if (specialOpenTimes.ContainsKey(openDayWeek) && specialOpenTimes[openDayWeek].ContainsKey(i))
                {
                    hourMinutes = specialOpenTimes[openDayWeek][i];
                }
            }
            else
            {
                var dayOfWeek = (int)openServerDay.AddTicks((i - 1) * TimeSpan.TicksPerDay).DayOfWeek;
                if (openTimes.ContainsKey(dayOfWeek))
                {
                    hourMinutes = openTimes[dayOfWeek];
                }
            }
            if (hourMinutes != null)
            {
                if (i < dayIndex)
                {
                    session += hourMinutes.Count;
                }
                else if (i == dayIndex)
                {
                    foreach (var hourMinute in hourMinutes)
                    {
                        if (hourMinute.AfterOpenTime(nowHour, nowMinute))
                        {
                            session++;
                        }
                    }
                }
            }
        }
        return session;
    }

    public bool ContainTimeNode(int week, int timeNode)
    {
        if ((DailyQuestType)id == DailyQuestType.CrossServerPk)
        {
            return false;
        }

        List<HourMinute> hourMinutes = null;

        var isMixServer = TimeUtility.IsMixServer && TimeUtility.MixOpenDay < GeneralDefine.mixServerCustomDays;
        if (isMixServer && mixServerOpenTimes.Count > 0)
        {
            week = week == 0 ? 7 : week;
            var todayWeek = (int)TimeUtility.ServerNow.DayOfWeek;
            todayWeek = todayWeek == 0 ? 7 : todayWeek;
            var targetMixOpenDay = week - todayWeek + TimeUtility.MixOpenDay;
            if (mixServerOpenTimes.Count > 0 && targetMixOpenDay >= 0 && targetMixOpenDay < GeneralDefine.mixServerCustomDays)
            {
                mixServerOpenTimes.TryGetValue(targetMixOpenDay + 1, out hourMinutes);
            }
            else
            {
                openTimes.TryGetValue(week, out hourMinutes);
            }
        }
        else
        {
            var openDayWeek = (int)TimeUtility.openServerDayOfWeek;
            var dayDelta = (week == 0 ? 7 : week) - (openDayWeek == 0 ? 7 : openDayWeek);
            if (TimeUtility.OpenWeekCnt < 1 && dayDelta < 0)
            {
                //openTimes.TryGetValue(week, out hourMinutes);

                if (specialOpenTimes.Count == 0)
                    openTimes.TryGetValue(week, out hourMinutes);
            }
            else
            {
                hourMinutes = GetHourMinuteByWeek(week);
            }
        }

        if (hourMinutes != null)
        {
            foreach (var item in hourMinutes)
            {
                if (item.hourBegin * 60 + item.minuteBegin == timeNode)
                {
                    return true;
                }
            }
        }

        return false;
    }

    private bool ContainWeek(int week)
    {
        week = week == 0 ? 7 : week;
        var todayWeek = (int)TimeUtility.ServerNow.DayOfWeek;
        todayWeek = todayWeek == 0 ? 7 : todayWeek;
        var isMixServer = TimeUtility.IsMixServer && TimeUtility.MixOpenDay < GeneralDefine.mixServerCustomDays;
        if (isMixServer && mixServerOpenTimes.Count > 0)
        {
            var targetMixOpenDay = week - todayWeek + TimeUtility.MixOpenDay;
            return mixServerOpenTimes.ContainsKey(targetMixOpenDay + 1);
        }
        else
        {
            var openDayWeek = (int)TimeUtility.openServerDayOfWeek;
            var dayDelta = (week == 0 ? 7 : week) - (openDayWeek == 0 ? 7 : openDayWeek);
            if (TimeUtility.OpenWeekCnt < 1 && dayDelta < 0)
            {
                if (specialOpenTimes.Count > 0)
                    return false;
                else
                    return openTimes.ContainsKey(week);
            }
            else
            {
                return GetHourMinuteByWeek(week) != null;
            }
        }
    }

    public string ToOpenTimeString()
    {
        if (always || openTimes.Count >= 7)
        {
            return Language.Get("DailyQuest_NoTimeLimit");
        }
        else
        {
            var timeStringList = new List<string>();
            for (var i = 1; i <= 7; i++)
            {
                var week = i % 7;
                if (ContainWeek(week))
                {
                    switch (week)
                    {
                        case 0:
                            timeStringList.Add(Language.Get("Weekday7"));
                            break;
                        case 1:
                            timeStringList.Add(Language.Get("Weekday1"));
                            break;
                        case 2:
                            timeStringList.Add(Language.Get("Weekday2"));
                            break;
                        case 3:
                            timeStringList.Add(Language.Get("Weekday3"));
                            break;
                        case 4:
                            timeStringList.Add(Language.Get("Weekday4"));
                            break;
                        case 5:
                            timeStringList.Add(Language.Get("Weekday5"));
                            break;
                        case 6:
                            timeStringList.Add(Language.Get("Weekday6"));
                            break;
                    }
                }
            }

            return string.Join(",", timeStringList.ToArray());
        }

    }

    public List<HourMinute> GetHourMinuteByWeek(int week)
    {
        var isMixServer = TimeUtility.IsMixServer && TimeUtility.MixOpenDay < GeneralDefine.mixServerCustomDays;
        if (isMixServer && mixServerOpenTimes.Count > 0)
        {
            week = week == 0 ? 7 : week;
            var todayWeek = (int)TimeUtility.ServerNow.DayOfWeek;
            todayWeek = todayWeek == 0 ? 7 : todayWeek;
            var targetMixOpenDay = week - todayWeek + TimeUtility.MixOpenDay;
            if (mixServerOpenTimes.ContainsKey(targetMixOpenDay + 1))
            {
                return mixServerOpenTimes[targetMixOpenDay + 1];
            }
            else
            {
                return null;
            }
        }
        else
        {
            var isSpecificDay = TimeUtility.OpenDay < 7;
            if (isSpecificDay && specialOpenTimes.Count > 0)
            {
                var openDayWeek = (int)TimeUtility.openServerDayOfWeek;
                var todayWeek = (int)TimeUtility.ServerNow.DayOfWeek;
                var dayDelta = ((week == 0 ? 7 : week) - (todayWeek == 0 ? 7 : todayWeek));
                var dayIndex = TimeUtility.OpenDay + 1 + dayDelta;
                if (specialOpenTimes.ContainsKey(openDayWeek) && specialOpenTimes[openDayWeek].ContainsKey(dayIndex))
                {
                    return specialOpenTimes[openDayWeek][dayIndex];
                }
            }
            else if (openTimes.ContainsKey(week % 7))
            {
                return openTimes[week % 7];
            }
        }

        return null;
    }

    public List<HourMinute> GetNormalHourMinutes()
    {
        foreach (var hourMinutes in openTimes.Values)
        {
            if (hourMinutes != null)
            {
                return hourMinutes;
            }
        }
        return null;
    }
}

public struct HourMinute
{
    public int hourBegin;
    public int minuteBegin;
    public int hourEnd;
    public int minuteEnd;
    public bool wholeDay;

    public HourMinute(string _input, int _duration)
    {
        var matches = Regex.Matches(_input, "[0-9]{1,2}");
        if (matches.Count >= 2)
        {
            hourBegin = int.Parse(matches[0].Value);
            minuteBegin = int.Parse(matches[1].Value);

            hourEnd = hourBegin + _duration / 60;
            minuteEnd = minuteBegin + _duration % 60;
            if (minuteEnd >= 60)
            {
                minuteEnd = minuteEnd % 60;
                hourEnd += 1;
            }

            wholeDay = false;
        }
        else
        {
            hourBegin = 0;
            minuteBegin = 0;
            hourEnd = 0;
            minuteEnd = 0;

            wholeDay = true;
        }
    }

    public HourMinute(int _hourBegin, int _minuteBegin, int _hourEnd, int _minuteEnd)
    {
        hourBegin = _hourBegin;
        minuteBegin = _minuteBegin;
        hourEnd = _hourEnd;
        minuteEnd = _minuteEnd;

        wholeDay = hourBegin == 0 && minuteBegin == 0 && hourEnd == 0 && minuteEnd == 0;

    }

    public bool InOpenTime()
    {
        if (wholeDay)
        {
            return true;
        }
        else
        {
            var minutes = TimeUtility.ServerNow.Hour * 60 + TimeUtility.ServerNow.Minute;
            if ((hourBegin * 60 + minuteBegin) <= minutes && (hourEnd * 60 + minuteEnd) > minutes)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

    public bool AfterOpenTime(int hour, int minute)
    {
        if (wholeDay)
        {
            return false;
        }
        else
        {
            var minutes = hour * 60 + minute;
            return (hourEnd * 60 + minuteEnd) <= minutes;
        }
    }

    public override string ToString()
    {
        var minuteBeginStr = minuteBegin > 9 ? minuteBegin.ToString() : StringUtility.Contact("0", minuteBegin);
        var minuteEndStr = minuteEnd > 9 ? minuteEnd.ToString() : StringUtility.Contact("0", minuteEnd);
        return StringUtility.Contact(hourBegin, ":", minuteBeginStr, "--", hourEnd, ":", minuteEndStr);
    }

    public string ToOpenTime()
    {
        if (minuteBegin < 10)
        {
            return StringUtility.Contact(hourBegin, ":0", minuteBegin);
        }
        else
        {
            return StringUtility.Contact(hourBegin, ":", minuteBegin);
        }
    }

    public static int Compare(HourMinute _lhs, HourMinute _rhs)
    {
        return (_lhs.hourBegin * 60 + _lhs.minuteBegin) < (_rhs.hourBegin * 60 + _rhs.minuteBegin) ? -1 : 1;
    }

}