package main

import (
	"encoding/json"
	"strconv"
	"time"

	"github.com/julienschmidt/httprouter"
)

var currentPromo uint = 0

func init() {
	router.GET("/api/users", apiHandler(
		func(httprouter.Params, []byte) HTTPResponse {
			return formatApiResponse(getUsers())
		}, adminRestricted))
	router.GET("/api/users/:uid", apiHandler(userHandler(
		func(u User, _ []byte) HTTPResponse {
			return APIResponse{u}
		}), loggedUser))
	router.PUT("/api/users/:uid", apiHandler(userHandler(updateUser), adminRestricted))
	router.DELETE("/api/users/:uid", apiHandler(userHandler(
		func(u User, _ []byte) HTTPResponse {
			return formatApiResponse(u.Delete())
		}), adminRestricted))
}

func userHandler(f func(User, []byte) HTTPResponse) func(httprouter.Params, []byte) HTTPResponse {
	return func(ps httprouter.Params, body []byte) HTTPResponse {
		if uid, err := strconv.Atoi(string(ps.ByName("uid"))); err != nil {
			if user, err := getUserByLogin(ps.ByName("uid")); err != nil {
				return APIErrorResponse{err: err}
			} else {
				return f(user, body)
			}
		} else if user, err := getUser(uid); err != nil {
			return APIErrorResponse{err: err}
		} else {
			return f(user, body)
		}
	}
}

type User struct {
	Id        int64     `json:"id"`
	Login     string    `json:"login"`
	Email     string    `json:"email"`
	Firstname string    `json:"firstname"`
	Lastname  string    `json:"lastname"`
	Time      time.Time `json:"time"`
	Promo     uint      `json:"promo"`
	Groups    string    `json:"groups"`
	IsAdmin   bool      `json:"is_admin"`
}

func getUsers() (users []User, err error) {
	if rows, errr := DBQuery("SELECT id_user, login, email, firstname, lastname, time, promo, groups, is_admin FROM users"); errr != nil {
		return nil, errr
	} else {
		defer rows.Close()

		for rows.Next() {
			var u User
			if err = rows.Scan(&u.Id, &u.Login, &u.Email, &u.Firstname, &u.Lastname, &u.Time, &u.Promo, &u.Groups, &u.IsAdmin); err != nil {
				return
			}
			users = append(users, u)
		}
		if err = rows.Err(); err != nil {
			return
		}

		return
	}
}

func getUser(id int) (u User, err error) {
	err = DBQueryRow("SELECT id_user, login, email, firstname, lastname, time, promo, groups, is_admin FROM users WHERE id_user=?", id).Scan(&u.Id, &u.Login, &u.Email, &u.Firstname, &u.Lastname, &u.Time, &u.Promo, &u.Groups, &u.IsAdmin)
	return
}

func getUserByLogin(login string) (u User, err error) {
	err = DBQueryRow("SELECT id_user, login, email, firstname, lastname, time, promo, groups, is_admin FROM users WHERE login=?", login).Scan(&u.Id, &u.Login, &u.Email, &u.Firstname, &u.Lastname, &u.Time, &u.Promo, &u.Groups, &u.IsAdmin)
	return
}

func userExists(login string) bool {
	var z int
	err := DBQueryRow("SELECT 1 FROM users WHERE login=?", login).Scan(&z)
	return err == nil && z == 1
}

func NewUser(login string, email string, firstname string, lastname string, groups string) (User, error) {
	t := time.Now()
	if res, err := DBExec("INSERT INTO users (login, email, firstname, lastname, time, promo, groups) VALUES (?, ?, ?, ?, ?, ?, ?)", login, email, firstname, lastname, t, currentPromo, groups); err != nil {
		return User{}, err
	} else if sid, err := res.LastInsertId(); err != nil {
		return User{}, err
	} else {
		return User{sid, login, email, firstname, lastname, t, currentPromo, groups, false}, nil
	}
}

func (u User) Update() (int64, error) {
	if res, err := DBExec("UPDATE users SET login = ?, email = ?, firstname = ?, lastname = ?, time = ?, promo = ?, groups = ? WHERE id_user = ?", u.Login, u.Email, u.Firstname, u.Lastname, u.Time, u.Promo, u.Groups, u.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (u User) MakeAdmin(value bool) (User, error) {
	if _, err := DBExec("UPDATE users SET is_admin = ? WHERE id_user = ?", value, u.Id); err != nil {
		return u, err
	} else {
		u.IsAdmin = value
		return u, err
	}
}

func (u User) Delete() (int64, error) {
	if res, err := DBExec("DELETE FROM users WHERE id_user = ?", u.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func ClearUsers() (int64, error) {
	if res, err := DBExec("DELETE FROM users"); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func updateUser(current User, body []byte) HTTPResponse {
	var new User
	if err := json.Unmarshal(body, &new); err != nil {
		return APIErrorResponse{err: err}
	}

	current.Login = new.Login
	current.Email = new.Email
	current.Firstname = new.Firstname
	current.Lastname = new.Lastname
	current.Time = new.Time
	current.Promo = new.Promo
	current.Groups = new.Groups
	return formatApiResponse(current.Update())
}