package main

import (
    "net/http"
    "time"
    "fmt"
    "encoding/json"

    "github.com/robfig/cron"
)

// CronTabの処理をやってくれるcron.CronとCronTabオブジェクトのマッピング
type cronServer struct {
    Server *cron.Cron
    Object cronTab
}

var cronServers = make(map[string]cronServer, 0)

// Kubernetesオブジェクトの`metadata`フィールド
type objectMeta struct {
    Name            string `json:"name"`
    UID             string `json:"uid,omitempty"`
    ResourceVersion string `json:"resourceVersion,omitempty"`
}

// リストで取ってきた場合のJSON型
type cronTabList struct {
    Items []cronTab `json:"items"`
}

type cronTabSpec struct {
    Schedule    string          `json:"schedule"`
    JobTemplate json.RawMessage `json:"jobTemplate"`
}

// CronTabオブジェクト
type cronTab struct {
    // The following fields mirror the fields in the third party resource.
    ObjectMeta objectMeta  `json:"metadata"`
    Spec       cronTabSpec `json:"spec"`
}

func main() {
    for {
        // APIを15秒ごとにポーリングする
        time.Sleep(15 * time.Second)
        resp, err := http.Get("http://localhost:8001/apis/alpha.ianlewis.org/v1/namespaces/default/crontabs")
        if err != nil {
            log.Printf("Could not connect to Kubernetes API: %v", err)
            continue
        }

        // APIから取ってきたJSONをデコード
        decoder := json.NewDecoder(resp.Body)
        var l cronTabList

        err = decoder.Decode(&l)
        if err != nil {
            log.Printf("Could not decode JSON event object: %v", err)
            continue
        }

        // 削除されたCronTabを処理する
        removeDeletedCronTabs(l)

        // 追加、更新されたCronTabを処理
        updateCronTabs(l)
    }
}

func removeDeletedCrontabs(l cronTabList) {
    for _, s := range cronServers {
        found := false
        for _, c := range l.Items {
            if c.ObjectMeta.UID == s.Object.ObjectMeta.UID {
                found = true
            }
        }
        if !found {
            removeCronTab(s.Object)
        }
    }
}

func updateCronTabs(l cronTabList) {
    for _, c := range l.Items {
        found := false
        for _, s := range cronServers {
            if c.ObjectMeta.UID == s.Object.ObjectMeta.UID {
                if c.ObjectMeta.ResourceVersion != s.Object.ObjectMeta.ResourceVersion {
                    log.Printf("Updating crontab %s", c.ObjectMeta.Name)
                    removeCronTab(s.Object)
                    err := addCronTab(c)
                    if err != nil {
                        log.Printf("Could not create crontab %#v: %v", c, err)
                    }
                }
                found = true
            }
        }
        if !found {
            err := addCronTab(c)
            if err != nil {
                log.Printf("Could not create crontab %#v: %v", c, err)
            }
        }
    }
}

func addCronTab(c cronTab) error {
    server := cron.New()

    // robfig/cronのCronは秒間のスケジュールに対応しているけど、
    // ここに標準のcronに追従して分間単位でスケジュールする
    spec := c.Spec.Schedule
    if !strings.HasPrefix(c.Spec.Schedule, "@") {
        spec = "0 " + c.Spec.Schedule
    }

    err := server.AddFunc(spec, func() {
        if err := runCronJob(c); err != nil {
            log.Printf("Error running cron job: %v", err)
        }
    })
    if err != nil {
        return fmt.Errorf("error adding crontab: %v", err)
    }

    cronServers[c.ObjectMeta.UID] = cronServer{
        Server: server,
        Object: c,
    }

    server.Start()

    log.Printf("Added crontab: %s", c.ObjectMeta.Name)

    return nil
}

func removeCronTab(c cronTab) {
    if server, ok := cronServers[c.ObjectMeta.UID]; ok {
        server.Server.Stop()
        delete(cronServers, c.ObjectMeta.UID)
        log.Printf("Removed crontab: %s", c.ObjectMeta.Name)
    }
}

type labels *map[string]string

type selector struct {
  MatchLabels labels `json:"matchLabels,omitempty"`
}

type jobTemplate struct {
  ObjectMeta      objectMeta       `json:"metadata"`
  JobTemplateSpec json.RawMessage `json:"spec,omitempty"`
}

type jobSpec struct {
  Selector *selector    `json:"selector,omitempty"`
  Template *jobTemplate `json:"template,omitempty"`
}

func runCronJob(c cronTab) error {
    name := makeJobName(c)
    log.Printf("Creating job %s for crontab %s", name, c.ObjectMeta.Name)

    job := job{
        ObjectMeta: objectMeta{
            Name: name,
        },
        JobSpec: jobSpec{
            Selector: &selector{
                MatchLabels: &map[string]string{
                    "name": name,
                },
            },
            Template: &jobTemplate{
                ObjectMeta: objectMeta{
                    Name: name,
                    Labels: &map[string]string{
                        "name": name,
                    },
                },
                JobTemplateSpec: &c.Spec.JobTemplate,
            },
        }
    }

    j, err := json.Marshal(job)
    if err != nil {
        return fmt.Errorf("could not marshal job to JSON: %s", err)
    }

    resp, err := http.Post("http://localhost:8001/apis/extensions/v1beta1/namespaces/default/jobs", "application/json", bytes.NewReader(j))
    if err != nil {
        return fmt.Errorf("HTTP request failed: %s", err)
    }

    return nil
}