package main

import (
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"html/template"
	"io/ioutil"
	"os"
	"sort"
	"time"
)

func handleErr(err error, str string, a ...interface{}) {
	a = append([]interface{}{err}, a...)
	if err != nil {
		fmt.Fprintf(os.Stderr, str, a...)
		os.Exit(1)
	}
}

func handleBool(ok bool, str string, a ...interface{}) {
	if !ok {
		fmt.Fprintf(os.Stderr, str, a...)
		os.Exit(1)
	}
}

var tmpl = template.Must(template.New("pem2html").
	Funcs(template.FuncMap{
		"red":           red,
		"green":         green,
		"date":          fDate,
		"datetime":      fDateTime,
		"colorDatetime": cDateTime,
	}).Parse(`<table class=sortable>
  <caption>
    <p>CT log (Updated {{.now | colorDatetime}})</p>
  </caption>
  <tr>
    <th>Logged</th>
    <th>NotBefore</th>
    <th>NotAfter</th>
    <th>Subject.CN</th>
    <th>Issuer.O</th>
  </tr>
{{range $cert := .certs}}
{{if and (eq $cert.X509.Subject.CommonName "andrewdm.me") (lt $cert.X509.NotBefore.Local.Year 2017)|not}}
  <tr>
    <td style="background-color: {{$cert.Updated        | green}}"><a target="_blank" href="{{$cert.Url}}">{{$cert.Updated        | date}}</a></td>
    <td style="background-color: {{$cert.X509.NotBefore | green}}"><a target="_blank" href="{{$cert.Url}}">{{$cert.X509.NotBefore | date}}</a></td>
    <td style="background-color: {{$cert.X509.NotAfter  | red  }}"><a target="_blank" href="{{$cert.Url}}">{{$cert.X509.NotAfter  | date}}</a></td>
    <td><a target="_blank" href="{{$cert.Url}}">{{$cert.X509.Subject.CommonName}}</a></td>
    <td><a target="_blank" href="{{$cert.Url}}">{{$cert.X509.Issuer.Organization}}</a></td>
  </tr>
{{end}}
{{end}}
</table>
`))

func fDate(t time.Time) template.HTML {
	return template.HTML(t.Local().Format("<time datetime=\"2006-01-02 15:04:05\" title=\"2006-01-02 15:04:05\">2006-01-02 <span class=time>15:04:05</span></time>"))
}

func fDateTime(t time.Time) template.HTML {
	return template.HTML(t.Local().Format("<time datetime=\"2006-01-02 15:04:05\">2006-01-02 15:04:05</time>"))
}

func cDateTime(t time.Time) template.HTML {
	return template.HTML(t.Local().Format("<time class=colordate datetime=\"2006-01-02 15:04:05\">2006-01-02 15:04:05</time>"))
}

func getNow() time.Time {
	stat, err := os.Stdin.Stat()
	if err == nil {
		return stat.ModTime()
	} else {
		return time.Now()
	}
}

var now = getNow()

type DateRange struct {
	a, b time.Time
}

func (dr DateRange) ToPct(point time.Time) float64 {
	dur_ab := dr.b.Sub(dr.a)
	dur_ap := point.Sub(dr.a)
	return float64(dur_ap) / float64(dur_ab)
}

type ByteRange struct {
	a, b byte
}

func (br ByteRange) FromPct(pct float64) byte {
	ab := int16(br.b) - int16(br.a)
	ap := int16(pct * float64(ab))
	return byte(int16(br.a) + ap)
}

func CapPct(pct float64) float64 {
	if pct < 0 {
		pct = 0
	} else if pct > 1 {
		pct = 1
	}
	return pct
}

func mapRange(dr DateRange, br ByteRange, t time.Time) byte {
	return br.FromPct(CapPct(dr.ToPct(t)))
}

func green(t time.Time) string {
	max := byte(0xF3)
	// 30 days ago: 0 green
	// now: max green
	greenness := mapRange(
		DateRange{now.AddDate(0, 0, -30), now},
		ByteRange{0, max},
		t)
	return fmt.Sprintf("#%02X%02X%02X", max-greenness, max, max-greenness)
}

func red(t time.Time) string {
	max := byte(0xF3)
	// now: max red
	// 30 days from now: 0 red
	redness := mapRange(
		DateRange{now, now.AddDate(0, 0, 30)},
		ByteRange{max, 0},
		t)
	return fmt.Sprintf("#%02X%02X%02X", max, max-redness, max-redness)
}

type Cert struct {
	Url     string
	Updated time.Time
	X509    *x509.Certificate
}

type Certs []Cert

// Len is the number of elements in the collection.
func (l Certs) Len() int {
	return len(l)
}

// Less reports whether the element with
// index i should sort before the element with index j.
func (l Certs) Less(i, j int) bool {
	return l[i].Updated.After(l[j].Updated)
}

// Swap swaps the elements with indexes i and j.
func (l Certs) Swap(i, j int) {
	tmp := l[i]
	l[i] = l[j]
	l[j] = tmp
}

func main() {
	data, err := ioutil.ReadAll(os.Stdin)
	handleErr(err, "Error reading stdin: %v\n")

	var certs Certs
	for len(data) > 0 {
		var certPem *pem.Block
		certPem, data = pem.Decode(data)

		var ok bool
		var cert Cert

		cert.Url, ok = certPem.Headers["X-Crt-Sh-Url"]
		handleBool(ok, "Did not get X-Crt-Sh-Url\n")

		str, ok := certPem.Headers["X-Crt-Sh-Updated"]
		handleBool(ok, "Did not get X-Crt-Sh-Updated\n")
		cert.Updated, err = time.Parse("2006-01-02T15:04:05Z", str)
		handleErr(err, "Could not parse updated time")

		cert.X509, err = x509.ParseCertificate(certPem.Bytes)
		handleErr(err, "Error parsing cert: %v\n")

		certs = append(certs, cert)
	}

	sort.Sort(certs)
	handleErr(tmpl.Execute(os.Stdout, map[string]interface{}{"certs": certs, "now": now}), "Could not execute template: %v\n")
}