package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"local/gziphttp"
	"local/router"
	"local/simpleserve/simpleserve"
	"net/http"
	"os"
	"path"
	"path/filepath"
	"regexp"
	"strings"
	"time"

	"github.com/google/uuid"
)

type Server struct {
	router *router.Router
	root   string
}

func NewServer(root string) *Server {
	return &Server{
		router: router.New(),
		root:   root,
	}
}

func (server *Server) Routes() error {
	wildcard := func(s string) string {
		return strings.TrimSuffix(s, "/") + "/" + router.Wildcard
	}
	wildcards := func(s string) string {
		return wildcard(wildcard(s))
	}
	_ = wildcards
	for path, handler := range map[string]func(http.ResponseWriter, *http.Request) error{
		"/":                        server.rootHandler,
		"/api/v0/tree":             server.apiV0TreeHandler,
		"/api/v0/media":            server.apiV0MediaHandler,
		wildcard("/api/v0/media"):  server.apiV0MediaIDHandler,
		"/api/v0/files":            server.apiV0FilesHandler,
		wildcard("/api/v0/files/"): server.apiV0FilesIDHandler,
		"/api/v0/search":           server.apiV0SearchHandler,
	} {
		if err := server.router.Add(path, server.tryCatchHttpHandler(handler)); err != nil {
			return err
		}
	}
	return nil
}

func (server *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	server.router.ServeHTTP(w, r)
}

func (server *Server) tryCatchHttpHandler(handler func(http.ResponseWriter, *http.Request) error) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if gziphttp.Can(r) {
			w2 := gziphttp.New(w)
			defer w2.Close()
			w = w2
		}
		if err := handler(w, r); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	}
}

func (server *Server) apiV0TreeHandler(w http.ResponseWriter, r *http.Request) error {
	_, pretty := r.URL.Query()["pretty"]
	if pretty {
		return server.apiV0TreePrettyHandler(w, r)
	}
	return server.apiV0TreePlainHandler(w, r)
}

func (server *Server) apiV0TreePrettyHandler(w http.ResponseWriter, r *http.Request) error {
	tree := server.tree()
	branches, err := tree.GetPretty()
	if err != nil {
		return err
	}
	return json.NewEncoder(w).Encode(branches)
}

func (server *Server) apiV0TreePlainHandler(w http.ResponseWriter, r *http.Request) error {
	tree := server.tree()
	branches, err := tree.Get()
	if err != nil {
		return err
	}
	return json.NewEncoder(w).Encode(branches)
}

func ensureAndWrite(p string, b []byte) error {
	if err := os.MkdirAll(path.Dir(p), os.ModePerm); err != nil {
		return err
	}
	return ioutil.WriteFile(p, b, os.ModePerm)
}

func (server *Server) apiV0MediaHandler(w http.ResponseWriter, r *http.Request) error {
	id, err := server.postContentHandler(path.Dir(server.diskMediaPath("id")), w, r)
	if err != nil {
		return err
	}
	return json.NewEncoder(w).Encode(map[string]map[string]string{
		"data": map[string]string{
			"filePath": path.Join("/api/v0/media", id),
		},
	})
}

func (server *Server) apiV0MediaIDHandler(w http.ResponseWriter, r *http.Request) error {
	switch r.Method {
	case http.MethodGet:
		return server.apiV0MediaIDGetHandler(w, r)
	case http.MethodDelete:
		return server.apiV0MediaIDDelHandler(w, r)
	}
	http.NotFound(w, r)
	return nil
}

func (server *Server) apiV0MediaIDDelHandler(w http.ResponseWriter, r *http.Request) error {
	id := path.Base(r.URL.Path)
	os.Remove(server.diskMediaPath(id))
	return nil
}

func (server *Server) apiV0MediaIDGetHandler(w http.ResponseWriter, r *http.Request) error {
	id := path.Base(r.URL.Path)
	return server.getContentHandler(server.diskMediaPath(id), w, r)
}

func (server *Server) getContentHandler(filePath string, w http.ResponseWriter, r *http.Request) error {
	if r.Method != http.MethodGet {
		return errors.New("not found")
	}
	f, err := os.Open(filePath)
	if os.IsNotExist(err) {
		http.NotFound(w, r)
		return nil
	}
	if err != nil {
		return err
	}
	defer f.Close()
	simpleserve.SetContentTypeIfMedia(w, r)
	io.Copy(w, f)
	return nil
}

func (server *Server) postContentHandler(fileDir string, w http.ResponseWriter, r *http.Request) (string, error) {
	if r.Method != http.MethodPost {
		return "", errors.New("not found")
	}
	id := uuid.New().String()
	if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data") {
		kb := int64(1 << 10)
		mb := kb << 10
		if err := r.ParseMultipartForm(10 * mb); err != nil {
			return "", err
		}
		if len(r.MultipartForm.File) != 1 {
			return "", errors.New("not exactly 1 file found in request")
		}
		for _, infos := range r.MultipartForm.File {
			if len(infos) != 1 {
				return "", errors.New("not exactly 1 file info found in request")
			}
			ext := path.Ext(infos[0].Filename)
			if h, ok := infos[0].Header["Content-Type"]; ok {
				ext = path.Base(h[0])
			}
			id += "." + ext
			f, err := infos[0].Open()
			if err != nil {
				return "", err
			}
			defer f.Close()
			r.Body = f
		}
	} else if strings.HasPrefix(r.Header.Get("Content-Type"), "application/x-www-form-urlencoded") {
		if err := r.ParseForm(); err != nil {
			return "", err
		}
		return "", fmt.Errorf("parse form: %+v", r.PostForm)
	}
	filePath := path.Join(fileDir, id)
	return id, server.putContentHandler(filePath, w, r)
}

func (server *Server) putContentHandler(filePath string, w http.ResponseWriter, r *http.Request) error {
	defer r.Body.Close()
	b, err := ioutil.ReadAll(r.Body)
	if err != nil {
		return err
	}
	return ensureAndWrite(filePath, b)
}

func (server *Server) rootHandler(w http.ResponseWriter, r *http.Request) error {
	return server.getContentHandler(path.Join(server.root, "index.html"), w, r)
}

func (server *Server) tree() *Tree {
	return NewTree(path.Join(server.root, "tree.yaml"))
}

func (server *Server) diskFilePath(id string) string {
	return path.Join(server.root, "files", id)
}

func (server *Server) diskMediaPath(id string) string {
	return path.Join(server.root, "media", id)
}

func (server *Server) apiV0FilesHandler(w http.ResponseWriter, r *http.Request) error {
	id, err := server.postContentHandler(path.Dir(server.diskFilePath("id")), w, r)
	if err != nil {
		return err
	}
	tree := server.tree()
	if pid := r.Header.Get("PID"); pid == "" {
	} else if branches, err := tree.Get(); err != nil {
		return err
	} else if _, ok := branches[pid]; !ok {
		return errors.New("bad pid")
	}
	if err := tree.Put(id, Branch{
		Title: r.Header.Get("Title"),
		PID:   r.Header.Get("PID"),
	}); err != nil {
		return err
	}
	return json.NewEncoder(w).Encode(map[string]map[string]string{
		"data": map[string]string{
			"filePath": path.Join("/api/v0/files", id),
		},
	})
}

func (server *Server) apiV0FilesIDHandler(w http.ResponseWriter, r *http.Request) error {
	switch r.Method {
	case http.MethodPut:
		return server.apiV0FilesIDPutHandler(w, r)
	case http.MethodGet:
		return server.apiV0FilesIDGetHandler(w, r)
	case http.MethodDelete:
		return server.apiV0FilesIDDelHandler(w, r)
	}
	http.NotFound(w, r)
	return nil
}

func (server *Server) apiV0FilesIDPutHandler(w http.ResponseWriter, r *http.Request) error {
	id := path.Base(r.URL.Path)
	tree := server.tree()
	branches, err := tree.Get()
	if err != nil {
		return err
	}
	branch, ok := branches[id]
	if !ok {
		http.NotFound(w, r)
		return nil
	}
	branch.Updated = time.Now().UTC()
	if title := r.Header.Get("Title"); title != "" {
		branch.Title = title
	}
	if pid := r.Header.Get("PID"); pid != "" {
		branch.PID = pid
	}
	branch.Deleted = false
	if err := server.putContentHandler(server.diskFilePath(id), w, r); err != nil {
		return err
	}
	return tree.Put(id, branch)
}

func (server *Server) apiV0FilesIDGetHandler(w http.ResponseWriter, r *http.Request) error {
	tree := server.tree()
	branches, err := tree.Get()
	if err != nil {
		return err
	}
	id := path.Base(r.URL.Path)
	branch, _ := branches[id]
	w.Header().Set("Title", branch.Title)
	w.Header().Set("PID", branch.PID)
	return server.getContentHandler(server.diskFilePath(id), w, r)
}

func (server *Server) apiV0FilesIDDelHandler(w http.ResponseWriter, r *http.Request) error {
	tree := server.tree()
	branches, err := tree.Get()
	if err != nil {
		return err
	}
	id := path.Base(r.URL.Path)
	branch, ok := branches[id]
	if !ok {
		return nil
	}
	branch.Deleted = true
	branch.Updated = time.Now().UTC()
	return tree.Put(id, branch)
}

func (server *Server) apiV0SearchHandler(w http.ResponseWriter, r *http.Request) error {
	query := r.URL.Query().Get("q")
	queries := strings.Split(query, " ")
	if len(queries) == 0 {
		w.Write([]byte(`[]`))
		return nil
	}
	patterns := []*regexp.Regexp{}
	unsafepattern := regexp.MustCompile(`[^a-zA-Z0-9]`)
	for _, query := range queries {
		if len(query) > 0 {
			query = unsafepattern.ReplaceAllString(query, ".")
			patterns = append(patterns, regexp.MustCompile(query))
		}
	}
	if len(patterns) == 0 {
		w.Write([]byte(`[]`))
		return nil
	}
	results := []string{}
	if err := filepath.Walk(path.Dir(server.diskFilePath("id")), func(p string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() {
			return nil
		}
		b, err := ioutil.ReadFile(p)
		if err != nil {
			return err
		}
		for _, pattern := range patterns {
			if !pattern.Match(b) {
				return nil
			}
		}
		results = append(results, path.Base(p))
		return err
	}); err != nil {
		return err
	}
	return json.NewEncoder(w).Encode(results)
}