s_cherry_e/sr/internal/extend/open_time/monthly.go

package openTime

import (
	"fmt"
	"sort"
	"strings"
	"time"

	cherryString "github.com/cherry-game/cherry/extend/string"
	ctime "github.com/cherry-game/cherry/extend/time"
)

type (
	monthlyParser struct{}

	monthly struct {
		times []*durationRange
	}
)

// 1-10/12:00-24:00|15-30/00:00-24:00
func (p *monthlyParser) Parse(params string) (OpenTime, error) {
	times := []*durationRange{}
	for _, v := range strings.Split(params, "|") {
		dt := strings.Split(v, "/")
		if len(dt) < 2 {
			return nil, fmt.Errorf("nonsupport params: %s", params)
		}

		ts := strings.Split(dt[1], "-")
		if len(ts) < 2 {
			return nil, fmt.Errorf("nonsupport params: %s", params)
		}

		startTime, err := parseDuration(ts[0])
		if err != nil {
			return nil, err
		}

		endTime, err := parseDuration(ts[1])
		if err != nil {
			return nil, err
		}

		ds := strings.Split(dt[0], "-")
		if len(ds) < 2 {
			return nil, fmt.Errorf("nonsupport params: %s", params)
		}

		startDay, ok := cherryString.ToInt64(ds[0])
		if !ok {
			return nil, fmt.Errorf("nonsupport params: %s", params)
		}

		endDay, ok := cherryString.ToInt64(ds[1])
		if !ok {
			return nil, fmt.Errorf("nonsupport params: %s", params)
		}

		for i := startDay; i <= endDay; i++ {
			newStartTime := time.Duration((i-1)*ctime.SecondsPerDay)*time.Second + startTime
			newEndTime := time.Duration((i-1)*ctime.SecondsPerDay)*time.Second + endTime
			times = append(times, &durationRange{
				startTime: newStartTime,
				endTime:   newEndTime,
			})
		}
	}

	sort.Slice(times, func(i, j int) bool { return times[i].startTime < times[j].startTime })

	return &monthly{times: times}, nil
}

func (p *monthly) Between(t *ctime.CherryTime) bool {
	duration := t.Sub(t.StartOfMonth().Time).Seconds()
	for _, v := range p.times {
		if v.startTime.Seconds() <= duration && duration <= v.endTime.Seconds() {
			return true
		}
	}
	return false
}

func (p *monthly) TimeRange(t *ctime.CherryTime) (ctime.CherryTime, ctime.CherryTime) {
	monthStart := t.StartOfMonth()
	monthEnd := t.EndOfMonth()
	duration := t.Sub(monthStart.Time).Seconds()
	for _, v := range p.times {
		if duration <= v.startTime.Seconds() || duration <= v.endTime.Seconds() {
			st := monthStart.Add(v.startTime)
			if st.After(monthEnd.Time) { // 开始时间比月结日大，下个月
				break
			}

			et := monthStart.Add(v.endTime)
			if et.After(monthEnd.Time) {
				et = monthEnd.Time
			}

			startTime := ctime.NewTime(st, true)
			endTime := ctime.NewTime(et, true)
			return startTime, endTime
		}
	}

	// 下个月
	t.AddMonth()
	nextTime := ctime.NewTime(t.StartOfMonth().Time, true)
	return p.TimeRange(&nextTime)
}