package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"

	"git.tilde.town/tildetown/bbj2/server/cmd/api"
	"git.tilde.town/tildetown/bbj2/server/cmd/config"
	"git.tilde.town/tildetown/bbj2/server/cmd/db"
	_ "github.com/mattn/go-sqlite3"
)

// TODO tests

func main() {
	var configFlag = flag.String("config", "config.yml", "A path to a config file.")
	var resetFlag = flag.Bool("reset", false, "reset the database. WARNING this wipes everything.")
	flag.Parse()
	io := config.IOStreams{
		Err: os.Stderr,
		Out: os.Stdout,
	}
	logger := log.New(io.Out, "", log.Ldate|log.Ltime|log.Lshortfile)
	opts := &config.Options{
		ConfigPath: *configFlag,
		Reset:      *resetFlag,
		IO:         io,
		Logger:     logger,
	}

	err := _main(opts)
	if err != nil {
		logger.Fatalln(err.Error())
	}
}

/*

TODO my next initiative is doing /something/ about the database layer.

The amount of boiler plate involved in:

- prepare a statement
- prepare a result struct
- execute statement
- scan into result

is wild; the error handling is really out of control. I need to think of abstractions for this. The "easiest" is just making blunt, non performant functions that return structs and a single error, but that could get out of control too. In general I think not having raw sql ever in application code is a good place to start.

*/

func _main(opts *config.Options) error {
	cfg, err := config.ParseConfig(opts.ConfigPath)
	if err != nil {
		fmt.Fprintf(os.Stderr, "could not read config file '%s'", opts.ConfigPath)
		os.Exit(1)
	}

	opts.Config = *cfg

	teardown, err := db.Setup(*opts)
	if err != nil {
		return fmt.Errorf("could not initialize DB: %w", err)
	}
	defer teardown()

	err = db.EnsureSchema(*opts)
	if err != nil {
		return err
	}

	setupAPI(*opts)

	// TODO TLS or SSL or something
	opts.Logger.Printf("starting server at %s:%d", cfg.Host, cfg.Port)
	if err := http.ListenAndServe(fmt.Sprintf("%s:%d", cfg.Host, cfg.Port), nil); err != nil {
		return fmt.Errorf("http server exited with error: %w", err)
	}

	return nil
}

func handler(opts config.Options, f http.HandlerFunc) http.HandlerFunc {
	// TODO make this more real
	return func(w http.ResponseWriter, req *http.Request) {
		opts.Logger.Printf("<- %s", req.URL.Path)
		// TODO add user info to opts
		f(w, req)
	}
}

func setupAPI(opts config.Options) {
	handleFailedAPICreate := func(w http.ResponseWriter, err error) {
		opts.Logger.Printf("failed to create API: %s", err.Error())
		w.WriteHeader(500)
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(api.BBJResponse{
			Error: true,
			Data:  "server error check logs",
		})
	}

	// TODO could probably generalize this even further but it's fine for now

	http.HandleFunc("/instance_info", handler(opts, func(w http.ResponseWriter, req *http.Request) {
		a, err := api.NewAPI(opts, req)
		if err != nil {
			handleFailedAPICreate(w, err)
			return
		}
		api.Invoke(w, a.InstanceInfo)
	}))

	http.HandleFunc("/user_register", handler(opts, func(w http.ResponseWriter, req *http.Request) {
		a, err := api.NewAPI(opts, req)
		if err != nil {
			handleFailedAPICreate(w, err)
			return
		}
		api.Invoke(w, a.UserRegister)
	}))

	/*
		func checkAuth(opts config.Options, username, hash string) error {
			db := opts.DB
			stmt, err := db.Prepare("select auth_hash from users where user_name = ?")
			if err != nil {
				return fmt.Errorf("db error: %w", err)
			}
			defer stmt.Close()

			opts.Logger.Printf("querying for %s", username)

			var authHash string
			if err = stmt.QueryRow(username).Scan(&authHash); err != nil {
				if strings.Contains(err.Error(), "no rows in result") {
					return errors.New("no such user")
				}
				return fmt.Errorf("db error: %w", err)
			}

			if authHash != hash {
				return errors.New("bad credentials")
			}

			return nil
		}

				http.HandleFunc("/user_register", handler(opts, func(w http.ResponseWriter, req *http.Request) {
					if req.Method != "POST" {
						badMethod(w)
						return
					}

					type AuthArgs struct {
						Username string `json:"user_name"`
						Hash     string `json:"auth_hash"`
					}

					var args AuthArgs
					if err := json.NewDecoder(req.Body).Decode(&args); err != nil {
						invalidArgs(w)
						return
					}

					if args.Hash == "" || args.Username == "" {
						invalidArgs(w)
						return
					}

					opts.Logf("querying for %s", args.Username)

					if err := checkAuth(opts, args.Username, args.Hash); err == nil {
						opts.Logf("found %s", args.Username)
						// code 4 apparently
						writeErrorResponse(w, 403, BBJResponse{
							Error: true,
							Data:  "user already exists",
						})
					} else if err.Error() != "no such user" {
						serverErr(w, err)
						return
					}

					db := opts.DB
					stmt, err := db.Prepare(`INSERT INTO users VALUES (?, ?, ?, "", "", 0, 0, ?)`)
					id, err := uuid.NewRandom()
					if err != nil {
						serverErr(w, err)
						return
					}

					_, err = stmt.Exec(id, args.Username, args.Hash, time.Now())
					if err != nil {
						serverErr(w, err)
					}

					writeResponse(w, BBJResponse{
						Data: true, // TODO probably something else
						// TODO prob usermap
					})
				}))

				http.HandleFunc("/check_auth", handler(opts, func(w http.ResponseWriter, req *http.Request) {
					if req.Method != "POST" {
						badMethod(w)
						return
					}

					type AuthArgs struct {
						Username string `json:"target_user"`
						AuthHash string `json:"target_hash"`
					}

					var args AuthArgs
					if err := json.NewDecoder(req.Body).Decode(&args); err != nil {
						invalidArgs(w)
						return
					}

					opts.Logf("got %s %s", args.Username, args.AuthHash)

					db := opts.DB

					stmt, err := db.Prepare("select auth_hash from users where user_name = ?")
					if err != nil {
						serverErr(w, err)
						return
					}
					defer stmt.Close()

					var authHash string
					err = stmt.QueryRow(args.Username).Scan(&authHash)
					if err != nil {
						if strings.Contains(err.Error(), "no rows in result") {
							opts.Logf("user not found")
							writeErrorResponse(w, 404, BBJResponse{
								Error: true,
								Data:  "user not found",
							})
						} else {
							serverErr(w, err)
						}
						return
					}

					// TODO unique constraint on user_name

					if authHash != args.AuthHash {
						http.Error(w, "incorrect password", 403)
						writeErrorResponse(w, 403, BBJResponse{
							Error: true,
							Data:  "incorrect password",
						})
						return
					}

					// TODO include usermap?
					writeResponse(w, BBJResponse{
						Data: true,
					})
				}))

				http.HandleFunc("/thread_index", handler(opts, func(w http.ResponseWriter, req *http.Request) {
					db := opts.DB
					rows, err := db.Query("SELECT * FROM threads JOIN messages ON threads.thread_id = messages.thread_id")
					if err != nil {
						serverErr(w, err)
						return
					}
					defer rows.Close()
					for rows.Next() {
						var id string
						err = rows.Scan(&id)
						if err != nil {
							serverErr(w, err)
							return
						}
						opts.Log(id)
					}
					writeResponse(w, BBJResponse{Data: "TODO"})
					// TODO
				}))

				http.HandleFunc("/thread_create", handler(opts, func(w http.ResponseWriter, req *http.Request) {
					if req.Method != "POST" {
						badMethod(w)
						return
					}

					// TODO make this getUserInfoFromReq or similar so we can use the user ID later
					user, err := getUserFromReq(opts, req)
					if err != nil {
						writeErrorResponse(w, 403, BBJResponse{
							Error: true,
							Data:  err.Error(),
						})
						return
					}

					type threadCreateArgs struct {
						Title   string
						Body    string
						SendRaw bool `json:"send_raw"`
					}

					var args threadCreateArgs
					if err := json.NewDecoder(req.Body).Decode(&args); err != nil {
						invalidArgs(w)
						return
					}

					if args.Title == "" || args.Body == "" {
						invalidArgs(w)
						return
					}

					db := opts.DB
					tx, err := db.Begin()
					if err != nil {
						serverErr(w, err)
						return
					}

					stmt, err := tx.Prepare("insert into threads VALUES ( ?, ?, ?, ?, ?, 0, 0, ? )")
					if err != nil {
						serverErr(w, err)
						return
					}
					defer stmt.Close()

					threadID, err := uuid.NewRandom()
					if err != nil {
						serverErr(w, err)
						return
					}
					now := time.Now()
					if _, err = stmt.Exec(
						threadID,
						user.ID,
						args.Title,
						now,
						now,
						user.Username,
					); err != nil {
						serverErr(w, err)
						return
					}

					stmt, err = tx.Prepare("insert into messages values ( ?, 1, ?, ?, 0, ?, ? )")
					if err != nil {
						serverErr(w, err)
						return
					}
					defer stmt.Close()

					if _, err = stmt.Exec(
						threadID,
						user.ID,
						now,
						args.Body,
						args.SendRaw,
					); err != nil {
						serverErr(w, err)
						return
					}

					if err = tx.Commit(); err != nil {
						serverErr(w, err)
						return
					}

					stmt, err = db.Prepare("select * from threads where thread_id = ? limit 1")
					if err != nil {
						serverErr(w, err)
						return
					}
					defer stmt.Close()

					t := &Thread{}

					// TODO fill in rest of thread
					if err = stmt.QueryRow(threadID).Scan(
						t.ID,
						t.Author,
						t.Title,
						t.LastMod,
						t.Created,
						t.ReplyCount,
						t.Pinned,
						t.LastAuthor,
					); err != nil {
						serverErr(w, err)
						return
					}

					stmt, err = db.Prepare("select * from messages where thread_id = ?")
					if err != nil {
						serverErr(w, err)
						return
					}
					defer stmt.Close()
					rows, err := stmt.Query(threadID)
					if err != nil {
						serverErr(w, err)
						return
					}

					t.Messages = []Message{}

					for rows.Next() {
						m := &Message{}
						if err := rows.Scan(
							m.ThreadID,
							m.PostID,
							m.Author,
							m.Created,
							m.Edited,
							m.Body,
							m.SendRaw,
						); err != nil {
							serverErr(w, err)
							return
						}
						t.Messages = append(t.Messages, *m)
					}

					writeResponse(w, BBJResponse{Data: t})

				}))
	*/
}