package main

import (
	//"bytes"
	//"encoding/hex"
	"fmt"
	"image"
	"os"
	//"image/jpeg"
	//"net/http"
	"git.giftfish.de/ston1th/webcam"
	"time"
)

var frame []byte
var img image.Image

func main() {
	cam, err := webcam.Open("/dev/video0", time.Second*5)
	if err != nil {
		panic(err.Error())
	}
	defer cam.Close()

	formats := cam.GetPixelFormats()
	println("Available formats: ")
	for k, value := range formats {
		fmt.Fprintln(os.Stderr, k, value)
	}

	//choice := readChoice(fmt.Sprintf("Choose format [1-%d]: ", len(formats)))
	//format := formats[1]
	format := uint32(1196444237) // MJPEG
	//format := PixelFormat(1448695129) // YUV

	fmt.Fprintf(os.Stderr, "Supported frame sizes for format %s\n", formats[format])
	fs := cam.GetFrameSizes(format)

	for _, f := range fs {
		fmt.Fprintln(os.Stderr, f)
	}
	//choice = readChoice(fmt.Sprintf("Choose format [1-%d]: ", len(frames)))
	s := fs[5]
	f, w, h, err := cam.SetImageFormat(format, s.MaxWidth, s.MaxHeight)

	if err != nil {
		panic(err.Error())
	} else {
		fmt.Fprintf(os.Stderr, "Resulting image format: %s (%dx%d)\n", formats[f], w, h)
	}

	fmt.Fprintf(os.Stderr, "Press Enter to start streaming\n")
	fmt.Scanf("\n")
	err = cam.StartStreaming()
	if err != nil {
		panic(err.Error())
	}

	for {
		err = cam.WaitForFrame()
		switch err.(type) {
		case nil:
		case webcam.TimeoutErr:
			continue
		default:
			panic(err.Error())
		}
		frm, err := cam.ReadFrame()
		if err == nil {
			//print(".")
			os.Stdout.Write(frm)
			os.Stdout.Sync()
		}
	}
}

/*
	buf := bytes.NewBuffer(frm)
	img, err = jpeg.Decode(buf)
	if err != nil {
		panic(err.Error())
	}

	http.HandleFunc("/", handler)
	panic(http.ListenAndServe(":8090", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	err := jpeg.Encode(w, img, nil)
	println(err)
}

/*
	imgchan := make(chan *image.Image)
	pr, pw := io.Pipe()

	go func() {
		for {
			frm, err := cam.ReadFrame()
			if err == nil {
				pw.Write(frm)
			}
			time.Sleep(time.Second)
		}
	}()

	go func() {
		img, err := mjpeg.Decode(pr)
		if err != nil {
			fmt.Println(err)
		}
	}()

	dec <- imgchan

	http.HandleFunc("/", handler)
	http.HandleFunc("/frame", handler2)
	panic(http.ListenAndServe(":8090", nil))
}

func handler2(w http.ResponseWriter, r *http.Request) {
	_, err := w.Write(frame)
	println(err)
}

func handler(w http.ResponseWriter, r *http.Request) {
	err := jpeg.Encode(w, *dec, nil)
	println(err)
}*/

/*package main

import (
	"bytes"
	fmt "fmt"
	"image"
	"image/jpeg"
	"net/http"
)

var frame []byte
var dec image.Image

func main() {
	cam, err := Open("/dev/video0")
	if err != nil {
		panic(err.Error())
	}
	defer cam.Close()

	err = cam.StartStreaming()
	if err != nil {
		panic(err.Error())
	}

	for {
		frame, err = cam.ReadFrame()
		if err == nil {
			break
		}
	}

	dec, err = jpeg.Decode(bytes.NewBuffer(frame))
	if err != nil {
		fmt.Println(err)
	}

	http.HandleFunc("/", handler)
	panic(http.ListenAndServe(":8090", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	err := jpeg.Encode(w, dec, nil)
	println(err)
}*/

/*import (
	"fmt"
	"image"
	"image/color"
	"image/jpeg"
	"net/http"
	"os"
)

const X = 800
const Y = 600

func div(f1, f2 float64) float64 {
	return ((f1 - f2) / f1) * 100
}

func check(i1, i2 uint32) bool {
	if i1 == i2 {
		return false
	}
	if i1 == 0 {
		return false
	}
	if i2 == 0 {
		return false
	}
	f1 := float64(i1)
	f2 := float64(i2)
	if div(f1, f2) > 5.00 {
		return true
	}
	return false
}

func comp(p1, p2 image.Image) image.Image {
	red := color.RGBA{255, 0, 0, 0}
	n := image.NewRGBA(p1.Bounds())
	for i := 0; i < X; i++ {
		for j := 0; j < Y; j++ {
			r1, g1, b1, _ := p1.At(i, j).RGBA()
			r2, g2, b2, _ := p2.At(i, j).RGBA()
			if check(r1, r2) || check(g1, g2) || check(b1, b2) {
				n.Set(i, j, red)
				continue
			}
			n.Set(i, j, p1.At(i, j))
		}
	}
	return n
}

var img image.Image
var test image.Image

func main() {
	f1, err := os.Open("pic1.jpeg")
	fmt.Println(err)
	f2, err := os.Open("pic2.jpeg")
	fmt.Println(err)
	p1, _, err := image.Decode(f1)
	fmt.Println(err)
	p2, _, err := image.Decode(f2)
	fmt.Println(err)
	img = comp(p1, p2)
	test = p1
	http.HandleFunc("/", handler)
	http.HandleFunc("/test", handler2)
	panic(http.ListenAndServe(":8090", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Println(jpeg.Encode(w, img, nil))
}
func handler2(w http.ResponseWriter, r *http.Request) {
	fmt.Println(jpeg.Encode(w, test, nil))
}*/