package main

import (
    "fmt"
    "github.com/robfig/cron/v3"
)

func main() {
    // 創建一個默認的cron對象
    c := cron.New()

    //添加執行任務
    c.AddFunc("30 * * * *", func() { fmt.Println("Every hour on the half hour") })
    c.AddFunc("@hourly", func() { fmt.Println("Every hour, starting an hour from now") })
    c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty, starting an hour thirty from now") })

    //開始執行任務
    c.Start()
    select {} //阻塞
}

// Entry 數據結構，每一個被調度實體一個
type Entry struct {
  // 唯一id，用于查詢和刪除
  ID EntryID
  // 本Entry的調度時間，不是絕對時間，在生成entry時會計算出來
  Schedule Schedule
  // 本entry下次需要執行的絕對時間，會一直被更新
  // 被封裝的含義是Job可以多層嵌套，可以實現基于需要執行Job的額外處理
  // 比如抓取Job異常、如果Job沒有返回下一個時間點的Job是還是繼續執行還是delay
  Next time.Time
  // 上一次被執行時間，主要用來查詢
  Prev time.Time
  // WrappedJob 是真實執行的Job實體
  WrappedJob Job
  // Job 主要給用戶查詢
  Job Job
}
// Cron保持任意數量的任務的軌道，調用相關的func時間表指定。它可以被啟動，停止，可運行的同時進行檢查。
type Cron struct {
  entries   []*Entry          // 保存了所有加入到 Cron 的任務
   // chain 用來定義entry里的warppedJob使用什么邏輯（e.g. skipIfLastRunning）
   // 即一個cron里所有entry只有一個封裝邏輯
  chain     Chain            
  stop      chan struct{}     // 停止整個cron的channel
  add       chan *Entry       // 增加一個entry的channel
  remove    chan EntryID      // 移除一個entry的channel
  snapshot  chan chan []Entry // 獲取entry整體快照的channel
  running   bool              // 代表是否已經在執行，是cron為使用者提供的動態修改entry的接口準備的
  logger    Logger            // 封裝golang的log包
  runningMu sync.Mutex        // 用來修改運行中的cron數據，比如增加entry，移除entry
  location  *time.Location    // 地理位置
  parser    ScheduleParser    // 對時間格式的解析，為interface, 可以定制自己的時間規則。
  nextID    EntryID           // entry的全局ID，新增一個entry就加1
  jobWaiter sync.WaitGroup    // run job時會進行add(1)， job 結束會done()，stop整個cron，以此保證所有job都能退出
}

func New(opts ...Option) *Cron {
	c := &Cron{
		entries:   nil,
		chain:     NewChain(),
		add:       make(chan *Entry),
		stop:      make(chan struct{}),
		snapshot:  make(chan chan []Entry),
		remove:    make(chan EntryID),
		running:   false,
		runningMu: sync.Mutex{},
		logger:    DefaultLogger,
		location:  time.Local,
		parser:    standardParser,
	}
	for _, opt := range opts {
		opt(c)
	}
	return c
}

func (c *Cron) AddFunc(spec string, cmd func()) (EntryID, error) {
	return c.AddJob(spec, FuncJob(cmd)) //包裝成job類型然后調用AddJob()方法
}

func (c *Cron) AddJob(spec string, cmd Job) (EntryID, error) {
	schedule, err := c.parser.Parse(spec) //將cron表達式解析成schedule類型
	if err != nil {
		return 0, err
	}
	return c.Schedule(schedule, cmd), nil //調用Schedule()
}

func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID {
	c.runningMu.Lock() //為了保證線程安全，加鎖
	defer c.runningMu.Unlock()
	c.nextID++ //下一EntryID
	entry := &Entry{
		ID:         c.nextID,
		Schedule:   schedule,
		WrappedJob: c.chain.Then(cmd),
		Job:        cmd,
	}
    // Cron是否處于運行狀態
	if !c.running {
		c.entries = append(c.entries, entry) // 追加到entries列表中
	} else {
		c.add <- entry // 發送到Cron的add chan
	}
	return entry.ID
}

func (c *Cron) Start() {
	c.runningMu.Lock() // 獲取鎖
	defer c.runningMu.Unlock()
	if c.running {
		return
	}
	c.running = true // 將 c.running 置為 true 表示 cron 已經在運行中了
	go c.run() //開啟一個 goroutine 執行 c.run()
}

// run the scheduler.. this is private just due to the need to synchronize
// access to the 'running' state variable.
func (c *Cron) run() {
	c.logger.Info("start")
 
	// Figure out the next activation times for each entry.
	now := c.now()
	for _, entry := range c.entries {
		entry.Next = entry.Schedule.Next(now)
		c.logger.Info("schedule", "now", now, "entry", entry.ID, "next", entry.Next)
	}
 
	for {
		// Determine the next entry to run.
		// 將定時任務執行時間進行排序,最近最早執行的放在前面
		sort.Sort(byTime(c.entries))
 
		var timer *time.Timer
		if len(c.entries) == 0 || c.entries[0].Next.IsZero() {
			// If there are no entries yet, just sleep - it still handles new entries
			// and stop requests.
			timer = time.NewTimer(100000 * time.Hour)
		} else {
			// 生成一個定時器,距離最近的任務時間到時 觸發定時器的channel,發送通知
			timer = time.NewTimer(c.entries[0].Next.Sub(now))
		}
 
		for {
			select {
			// 定時時間到了,執行定時任務,并設置下次執行的時刻
			case now = <-timer.C:
				now = now.In(c.location)
				c.logger.Info("wake", "now", now)
 
				// Run every entry whose next time was less than now
				//對每個定時任務嘗試執行
				for _, e := range c.entries {
					if e.Next.After(now) || e.Next.IsZero() {
						break
					}
					c.startJob(e.WrappedJob)
					e.Prev = e.Next
					e.Next = e.Schedule.Next(now)
					c.logger.Info("run", "now", now, "entry", e.ID, "next", e.Next)
				}
			//新增的定時任務添加到 任務列表中
			case newEntry := <-c.add:
				timer.Stop()
				now = c.now()
				newEntry.Next = newEntry.Schedule.Next(now)
				c.entries = append(c.entries, newEntry)
				c.logger.Info("added", "now", now, "entry", newEntry.ID, "next", newEntry.Next)
			//獲取 當前所有定時任務(快照)
			case replyChan := <-c.snapshot:
				replyChan <- c.entrySnapshot()
				continue
			//停止定時任務,timer停止即可完成此功能
			case <-c.stop:
				timer.Stop()
				c.logger.Info("stop")
				return
			//刪除某個定時任務
			case id := <-c.remove:
				timer.Stop()
				now = c.now()
				c.removeEntry(id)
				c.logger.Info("removed", "entry", id)
			}
 
			break
		}
	}
}

func (c *Cron) Stop() context.Context {
	c.runningMu.Lock()
	defer c.runningMu.Unlock()
	if c.running {
		c.stop <- struct{}{} // 會發出一個 stop 信號
		c.running = false
	}
	ctx, cancel := context.WithCancel(context.Background())
	go func() {
         // 等待所有已經在執行的任務執行完畢
		c.jobWaiter.Wait()
         // 會發出一個 cancelCtx.Done() 信號
		cancel()
	}()
	return ctx
}

func (c *Cron) Remove(id EntryID) {
	c.runningMu.Lock()
	defer c.runningMu.Unlock()
	if c.running {
		c.remove <- id // 會發出一個 remove 信號
	} else {
		c.removeEntry(id)
	}
}

func (c *Cron) removeEntry(id EntryID) {
	var entries []*Entry
	for _, e := range c.entries {
		if e.ID != id {
			entries = append(entries, e)
		}
	}
	c.entries = entries
}