package main

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

	"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(s) + router.Wildcard
	}
	_ = 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,
		wildcards("/api/v0/files"): server.apiV0FilesHandler,
		"/api/v0/search":           server.apiV0SearchHandler,
	} {
		log.Printf("listening for %s", path)
		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 {
	tree := server.tree()
	branches, err := tree.GetRootMeta()
	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 := uuid.New().String()
	filePath, err := server.postContentHandler(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", path.Base(filePath)),
		},
	})
}

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(filePath string, w http.ResponseWriter, r *http.Request) (string, error) {
	if r.Method != http.MethodPost {
		return "", errors.New("not found")
	}
	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])
			}
			filePath += "." + 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)
	}
	return filePath, 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, "files"))
}

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 {
	switch r.Method {
	case http.MethodPost:
		return server.apiV0FilesPostHandler(w, r)
	case http.MethodGet:
		return server.apiV0FilesIDGetHandler(w, r)
	case http.MethodPut:
		return server.apiV0FilesIDPutHandler(w, r)
	case http.MethodDelete:
		return server.apiV0FilesIDDelHandler(w, r)
	}
	http.NotFound(w, r)
	return nil
}

func (server *Server) apiV0FilesPostHandler(w http.ResponseWriter, r *http.Request) error {
	f, err := ioutil.TempFile(os.TempDir(), "filesPost*")
	if err != nil {
		return err
	}
	f.Close()
	defer os.Remove(f.Name())

	filePath, err := server.postContentHandler(f.Name(), w, r)
	if err != nil {
		return err
	}
	defer os.Remove(filePath)

	b, err := ioutil.ReadFile(filePath)
	if err != nil {
		return err
	}

	pid := server.fileId(r)
	id := append(pid, strings.Split(uuid.New().String(), "-")[0])
	if err := server.tree().Put(id, Leaf{Title: r.Header.Get("Title"), Content: string(b)}); err != nil {
		return err
	}
	return json.NewEncoder(w).Encode(map[string]map[string]string{
		"data": map[string]string{
			"filePath": path.Join("/api/v0/files/", server.urlFileId(id)),
		},
	})
}

func (server *Server) apiV0FilesIDGetHandler(w http.ResponseWriter, r *http.Request) error {
	id := server.fileId(r)
	if len(id) == 0 || id[0] == "" {
		return fmt.Errorf("no id found: %+v", id)
	}

	leaf, err := server.tree().Get(id)
	if os.IsNotExist(err) {
		http.NotFound(w, r)
		return nil
	} else if err != nil {
		return err
	}

	w.Header().Set("Title", leaf.Title)
	_, err = w.Write([]byte(leaf.Content))
	return err
}

func (server *Server) apiV0FilesIDDelHandler(w http.ResponseWriter, r *http.Request) error {
	id := server.fileId(r)
	if len(id) == 0 || id[0] == "" {
		return fmt.Errorf("no id found: %+v", id)
	}

	leaf, err := server.tree().Get(id)
	if os.IsNotExist(err) {
		return nil
	} else if err != nil {
		return err
	}
	leaf.Deleted = true

	return server.tree().Put(id, leaf)
}

func (server *Server) urlFileId(id []string) string {
	if len(id) == 0 {
		return ""
	}
	result := id[0]
	for i := 1; i < len(id); i++ {
		result = strings.Join([]string{result, url.PathEscape(id[i])}, "/")
	}
	return result
}

func (server *Server) fileId(r *http.Request) []string {
	return strings.Split(
		strings.Trim(
			strings.TrimPrefix(
				strings.Trim(r.URL.Path, "/"),
				"api/v0/files",
			),
			"/"),
		"/",
	)
}

func (server *Server) apiV0FilesIDPutHandler(w http.ResponseWriter, r *http.Request) error {
	id := server.fileId(r)
	if len(id) == 0 || id[0] == "" {
		return fmt.Errorf("no id found: %+v", id)
	}

	leaf, err := server.tree().Get(id)
	if os.IsNotExist(err) {
	} else if err != nil {
		return err
	}
	b, err := ioutil.ReadAll(r.Body)
	if err != nil {
		return err
	}

	leaf.Content = string(b)
	leaf.Title = r.Header.Get("Title")
	leaf.Deleted = false

	if err := server.tree().Put(id, leaf); err != nil {
		return err
	}
	return json.NewEncoder(w).Encode(map[string]map[string]string{
		"data": map[string]string{
			"filePath": path.Join("/api/v0/files/", server.urlFileId(id)),
		},
	})
}

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("(?i)"+query))
		}
	}
	if len(patterns) == 0 {
		w.Write([]byte(`[]`))
		return nil
	}
	tree, err := server.tree().GetRoot()
	if err != nil {
		return err
	}
	result := []string{}
	if err := tree.ForEach(func(id []string, leaf Leaf) error {
		for _, pattern := range patterns {
			if !pattern.MatchString(leaf.Content) && !pattern.MatchString(leaf.Title) {
				return nil
			}
		}
		result = append(result, server.urlFileId(id))
		return nil
	}); err != nil {
		return err
	}
	return json.NewEncoder(w).Encode(result)
}