# Pastebin qtZlkf59
package main

import (
	"bytes"
	"encoding/json"
	"html/template"
	"log"
	"net/http"
	"os"
	"os/exec"
	"strings"
)

type versionCheckBody struct {
	Offers []offer `json:"offers"`
}

type offer struct {
	Response string `json:"response"`
	Download string `json:"download"`
	Locale   string `json:"locale"`
	Packages struct {
		Full       string `json:"full"`
		NoContent  string `json:"no_content"`
		NewBundled string `json:"new_bundled"`
		Partial    bool   `json:"partial"`
		Rollback   bool   `json:"rollback"`
	} `json:"packages"`
	Current        string `json:"current"`
	Version        string `json:"version"`
	PhpVersion     string `json:"php_version"`
	MysqlVersion   string `json:"mysql_version"`
	NewBundled     string `json:"new_bundled"`
	PartialVersion bool   `json:"partial_version"`
}

func get(url string) *http.Response {
	log.Println("Downloading", url)
	resp, err := http.Get(url)
	assert(err)
	return resp
}

func main() {
	resp := get("https://api.wordpress.org/core/version-check/1.7/")
	defer func() { assert(resp.Body.Close()) }()

	vcb := &versionCheckBody{}
	assert(json.NewDecoder(resp.Body).Decode(vcb))

	for _, offer := range vcb.Offers {
		if offer.Version == "4.9.8" && offer.Response == "upgrade" {
			downloadTranslations(offer.Version)
		}
	}
}

func downloadTranslations(version string) {
	resp := get("https://api.wordpress.org/translations/core/1.0/?version=" + version)
	defer func() { assert(resp.Body.Close()) }()

	tb := &translationsBody{}
	assert(json.NewDecoder(resp.Body).Decode(tb))

	hashes := map[string]map[string]string{}
	cache := loadCache()

	for _, translation := range tb.Translations {
		hashes[translation.Language] = map[string]string{
			"version":      translation.Version,
			"english_name": translation.EnglishName,
			"updated":      translation.Updated,
			"url":          translation.Package,
			"sha256":       downloadTranslation(cache, translation),
		}
	}

	file, err := os.Create("wordpress_translations.nix")
	assert(err)

	t := template.Must(template.New("translations").Parse(strings.TrimSpace(`
{
{{- range $key, $value := .}}
  {{$key}} = {
    version = "{{$value.version}}";
    updated = "{{$value.updated}}";
    english_name = "{{$value.english_name}}";
    url = {{$value.url}};
    sha256 = "{{$value.sha256}}";
  };
{{- end -}}
}
	`)))

	assert(t.Execute(file, hashes))
}

func downloadTranslation(cache *nixInfo, tr translation) string {
	if cache != nil {
		info, found := (*cache)[tr.Language]
		if found {
			if info.Version == tr.Version && info.Updated == tr.Updated && info.URL == tr.Package {
				log.Println("Found in cache", info.SHA256, info.URL)
				return info.SHA256
			}
		}
	}

	log.Println("nix-prefetch-url", tr.Package)

	cmd := exec.Command("nix-prefetch-url", tr.Package)
	output, err := cmd.Output()
	assert(err)

	hash := strings.TrimSpace(string(output))
	log.Println(hash)
	return hash
}

func loadCache() *nixInfo {
	cmd := exec.Command("nix", "eval", "--json", "(import ./wordpress_translations.nix)")
	output, err := cmd.Output()
	if err != nil {
		log.Println(err)
		return nil
	}

	info := &nixInfo{}
	assert(json.NewDecoder(bytes.NewBuffer(output)).Decode(info))
	return info
}

func assert(err error) {
	if err != nil {
		log.Fatalln(err)
	}
}

type nixInfo map[string]struct {
	EnglishName string `json:"english_name"`
	SHA256      string `json:"sha256"`
	Updated     string `json:"updated"`
	URL         string `json:"url"`
	Version     string `json:"version"`
}

type translationsBody struct {
	Translations []translation `json:"translations"`
}

type translation struct {
	Language    string `json:"language"`
	Version     string `json:"version"`
	Updated     string `json:"updated"`
	EnglishName string `json:"english_name"`
	NativeName  string `json:"native_name"`
	Package     string `json:"package"`
}