package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"html/template"
	"io"
	"io/ioutil"
	"local/gziphttp"
	"local/router"
	"local/simpleserve/simpleserve"
	"log"
	"net/http"
	"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,
		"/ui":                      server.rootHandler,
		"/ui/search":               server.uiSearchHandler,
		wildcards("/ui/files"):     server.uiFilesHandler,
	} {
		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)
			log.Printf("failed handling %s: %v", r.URL.String(), err)
		}
	}
}

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.MethodPut:
		return server.apiV0MediaIDPutHandler(w, r)
	case http.MethodDelete:
		return server.apiV0MediaIDDelHandler(w, r)
	}
	http.NotFound(w, r)
	return nil
}

func (server *Server) apiV0MediaIDPutHandler(w http.ResponseWriter, r *http.Request) error {
	panic("not impl")
}

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) uiSearchHandler(w http.ResponseWriter, r *http.Request) error {
	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/ui/files")
	t, err := server.uiSubTemplates()
	if err != nil {
		return err
	}
	t, err = t.ParseFiles(path.Join(server.root, "ui", "search.ctmpl"))
	if err != nil {
		return err
	}
	idsTitles, err := server._apiV0SearchHandler(r.URL.Query().Get("q"))
	if err != nil {
		return err
	}
	data := make([]struct {
		Title string
		ID    string
	}, len(idsTitles))
	for i := range idsTitles {
		data[i].ID = idsTitles[i][0]
		data[i].Title = idsTitles[i][1]
	}
	return t.Lookup("search").Execute(w, map[string]interface{}{"Results": data})
}

func (server *Server) uiFilesHandler(w http.ResponseWriter, r *http.Request) error {
	id := NewID(strings.TrimPrefix(r.URL.Path, "/ui/files"))
	if id == "" {
		return server.rootHandler(w, r)
	}
	t, err := server.uiSubTemplates()
	if err != nil {
		return err
	}
	t, err = t.ParseFiles(path.Join(server.root, "ui", "files.ctmpl"))
	if err != nil {
		return err
	}
	tree := server.tree()
	branches, err := tree.GetRootMeta()
	if err != nil {
		return err
	}
	branchesJSON, err := json.Marshal(branches)
	if err != nil {
		return err
	}
	var parent Leaf
	if id.Pop() != "" {
		parent, err = tree.Get(id.Pop())
		if err != nil {
			return fmt.Errorf("failed to get pid %q: %v", id.Pop(), err)
		}
	}
	leaf, err := tree.Get(id)
	if err != nil {
		if id.Pop() != "" {
			return fmt.Errorf("failed to get id %q: %v", id, err)
		}
		leaf.Title = "My New File"
	}
	data := map[string]interface{}{
		"This": map[string]string{
			"Title":   leaf.Title,
			"Content": leaf.Content,
			"ID":      r.URL.Path,
			"PID":     strings.TrimPrefix(path.Dir(r.URL.Path), "/"),
			"PTitle":  parent.Title,
		},
		"Tree": string(branchesJSON),
	}
	return t.Lookup("files").Execute(w, data)
}

func (server *Server) uiSubTemplates() (*template.Template, error) {
	templateFiles := []string{}
	var loadTemplateFilesFromDir func(string) error
	loadTemplateFilesFromDir = func(root string) error {
		entries, err := os.ReadDir(root)
		if err != nil {
			return err
		}
		for _, entry := range entries {
			entryPath := path.Join(root, entry.Name())
			if entry.IsDir() {
				if err := loadTemplateFilesFromDir(entryPath); err != nil {
					return err
				}
			} else if !strings.HasPrefix(path.Base(entryPath), "_") {
			} else if strings.HasSuffix(entryPath, ".ctmpl") {
				templateFiles = append(templateFiles, entryPath)
			}
		}
		return nil
	}
	if err := loadTemplateFilesFromDir(path.Join(server.root, "ui")); err != nil {
		return nil, err
	}
	return template.ParseFiles(templateFiles...)
}

func (server *Server) rootHandler(w http.ResponseWriter, r *http.Request) error {
	http.Redirect(w, r, "/ui/files/"+uuid.New().String()[:5], 301)
	return nil
}

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 := NewID(pid).Push(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/", id.URLSafeString()),
		},
	})
}

func (server *Server) apiV0FilesIDGetHandler(w http.ResponseWriter, r *http.Request) error {
	id := NewID(server.fileId(r))
	if id.String() == "" {
		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 := NewID(server.fileId(r))
	if id.String() == "" {
		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) fileId(r *http.Request) string {
	return strings.Trim(
		strings.TrimPrefix(
			strings.Trim(r.URL.Path, "/"),
			"api/v0/files",
		),
		"/",
	)
}

func (server *Server) apiV0FilesIDPutHandler(w http.ResponseWriter, r *http.Request) error {
	id := NewID(server.fileId(r))
	if id.String() == "" {
		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/", id.URLSafeString()),
		},
	})
}

func (server *Server) apiV0SearchHandler(w http.ResponseWriter, r *http.Request) error {
	query := r.URL.Query().Get("q")
	idsTitles, err := server._apiV0SearchHandler(query)
	if err != nil {
		return err
	}
	result := make([]string, len(idsTitles))
	for i := range idsTitles {
		result[i] = idsTitles[i][0]
	}
	return json.NewEncoder(w).Encode(result)
}

func (server *Server) _apiV0SearchHandler(query string) ([][2]string, error) {
	queries := strings.Split(query, " ")
	if len(queries) == 0 {
		return [][2]string{}, 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 {
		return [][2]string{}, nil
	}
	tree, err := server.tree().GetRoot()
	if err != nil {
		return nil, err
	}
	result := [][2]string{}
	if err := tree.ForEach(func(id ID, leaf Leaf) error {
		for _, pattern := range patterns {
			if !pattern.MatchString(leaf.Content) && !pattern.MatchString(leaf.Title) {
				return nil
			}
		}
		title := leaf.Title
		pid := id.Pop()
		for pid != "" {
			parent, err := server.tree().Get(pid)
			if err != nil {
				return err
			}
			title = path.Join(parent.Title, title)
			pid = pid.Pop()
		}
		result = append(result, [2]string{id.URLSafeString(), title})
		return nil
	}); err != nil {
		return nil, err
	}
	return result, nil
}