package main

import (
	"fmt"
    // #1: net/http contains http.ServeMux, the express equivalent
	"net/http"
)

// #3: Let's make the port a constant
const port = 3000

func main() {
    // #2: http.NewServeMux() mimics express()
	mux := http.NewServeMux()

    // #4: http.ServeMux lacks method-specific handlers,
	// so we specify the method before the path.  Not
	// specifying a method makes this HandlerFunc respond
	// to every request, including PUT, POST, and DELETE.
	mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		// #5: fmt.Fprint writes to anything that implements
		// io.Writer, which http.ResponseWriter does, so
		// "Hello World!" gets sent to the browser.
		fmt.Fprint(w, "Hello World!")
	})

	// #6: http.ListenAndServe is the equivalent of
	// app.Listen.  http.ListenAndServe can take either
	// nil, which uses the default ServeMux, or a custom
	// ServeMux, which is mux in our case.
	http.ListenAndServe(fmt.Sprint(":", port), mux)
}

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
)

const (
	// #1: Use constants to avoid typos.
	// This converts most typo-induced runtime errors
	// into compile Sun Sep  8 21:52:50 2024errors.
	contentLength = "Content-Length"
	contentType   = "Content-Type"
)

const port = 8080

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /video", func(w http.ResponseWriter, r *http.Request) {
		videoPath := "../videos/SampleVideo_1280x720_1mb.mp4"
		// #2: Let's open videoPath.
		videoReader, err := os.Open(videoPath)
		if err != nil {
			// #3: Fail early on error.
			w.WriteHeader(http.StatusNotFound)
			return
		}
		// #4: defer runs the given function right before
		// the function ends, so be sure we close the file
		// if we can successfully open it.
		defer videoReader.Close()

		// #5: videoReader.Stat() is the same as fs.promises.stat.
		// we use it to get the size, failing if we can't read the
		// file statistics.
		videoStats, err := videoReader.Stat()
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		// #6: videoStats.Size() returns a 64bit integer.
		// w.Header().Add(header, value) expects a string, so
		// strconv.FormatInt converts an integer into a string
		// with the given base: 10, in this case.
		w.Header().Add(contentLength, strconv.FormatInt(videoStats.Size(), 10))
		// #7: Set the Content-Type to video/mp4 so the browser can
		// interpret it correctly.
		w.Header().Add(contentType, "video/mp4")

		// #8: Finally, use io.Copy to stream to the browser.
		// This is the same as piping the video data to res.
		io.Copy(w, videoReader)
	})

	// #9: Starts the http.ServeMux.
	http.ListenAndServe(fmt.Sprint(":", port), mux)
}

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strconv"
)

const (
	contentLength = "Content-Length"
	contentType   = "Content-Type"
)

func main() {
	// #1: Look the PORT environment variable.
	// Extract its value and learn if it was found.
	port, found := os.LookupEnv(`PORT`)
	// #2: If PORT wasn't provided, we fail and the server never starts.
	if !found {
		log.Fatal(`Please specify the port number for the HTTP server with the environment variable PORT.`)
	}

	mux := http.NewServeMux()
	mux.HandleFunc("GET /video", func(w http.ResponseWriter, r *http.Request) {
		videoPath := "../videos/SampleVideo_1280x720_1mb.mp4"
		videoReader, err := os.Open(videoPath)
		if err != nil {
			w.WriteHeader(http.StatusNotFound)
			return
		}
		defer videoReader.Close()
		videoStats, err := videoReader.Stat()
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		w.Header().Add(contentLength, strconv.FormatInt(videoStats.Size(), 10))
		w.Header().Add(contentType, "video/mp4")
		io.Copy(w, videoReader)
	})

	http.ListenAndServe(fmt.Sprint(":", port), mux)
}