package main

import (
    "fmt"
    "image"
    "image/color"
    "image/gif"
    "io"
    "log"
    "math"
    "math/rand"
    "net/http"
    "strconv"
    "sync"
    "time"
)

var mu sync.Mutex
var count int
var palette = []color.Color{color.White, color.Black}

const (
    whiteIndex = 0
    blackIndex = 1
)

func main() {
    http.HandleFunc("/", handler)
    http.HandleFunc("/count", counter)
    http.HandleFunc("/lissaju", func(w http.ResponseWriter, r *http.Request) {

        if err := r.ParseForm(); err != nil {
            log.Print(err)
        }
        cyc := 5.0
        del := 5
        for k, v := range r.Form {
            if k == "cycle" {
                i, err := strconv.Atoi(v[0])
                if err != nil {
                    fmt.Printf("Error")
                } else {
                    cyc = float64(i)
                }

            }

            if k == "delay" {
                i, err := strconv.Atoi(v[0])
                if err != nil {
                    fmt.Printf("Error")
                } else {
                    del = i
                }

            }
        }
        lissajous(w, cyc, del)
    })
    log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func counter(w http.ResponseWriter, r *http.Request) {
    mu.Lock()
    fmt.Fprintf(w, "counter= %d\n", count)
    mu.Unlock()
}

func handler(w http.ResponseWriter, r *http.Request) {

    mu.Lock()
    count++
    mu.Unlock()

    fmt.Fprintf(w, "%s %s %s\n", r.Method, r.URL, r.Proto)
    for k, v := range r.Header {
        fmt.Fprintf(w, "Header[%q] = %q\n", k, v)
    }
    fmt.Fprintf(w, "Host = %q\n", r.Host)
    fmt.Fprintf(w, "RemoteAddr = %q\n", r.RemoteAddr)
    if err := r.ParseForm(); err != nil {
        log.Print(err)
    }
    for k, v := range r.Form {
        fmt.Fprintf(w, "Form[%q] = %q\n", k, v)
    }
}

func lissajous(out io.Writer, cyc float64, del int) {

    cycles := cyc
    delay := del

    const (
        res     = 0.001
        size    = 400
        nframes = 100
    )

    rand.Seed(time.Now().UTC().UnixNano())
    freq := rand.Float64() * 3.0
    anim := gif.GIF{LoopCount: nframes}

    phase := 0.0
    for i := 0; i < nframes; i++ {
        rect := image.Rect(0, 0, 2*size+1, 2*size+1)
        img := image.NewPaletted(rect, palette)
        for t := 0.0; t < cycles*2*math.Pi; t += res {
            x := math.Sin(t)
            y := math.Sin(t*freq + phase)
            img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blackIndex)
        }
        phase += 0.1
        anim.Delay = append(anim.Delay, delay)
        anim.Image = append(anim.Image, img)
    }
    gif.EncodeAll(out, &anim)
}