package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"unicode/utf8"
)

// *func
// return uid,isvalid
func f_cookieGetUid(r *http.Request) (int, bool) {
	token, err := r.Cookie("token")
	if err != nil {
		return -1, false
	}
	uid, err := parseToken(token.Value)
	if err != nil {
		return -1, false
	}
	return uid, true
}

// return uid,isvalid
func f_adminCookieGetUid(r *http.Request) (int, bool) {
	token, err := r.Cookie("admin_token")
	if err != nil {
		return -1, false
	}
	uid, err := parseToken(token.Value)
	if err != nil {
		return -1, false
	}
	return uid, true
}

func f_readBody(r *http.Request) ([]byte, error) {
	return ioutil.ReadAll(r.Body)
}

func f_sendReq(uid int, url string, w http.ResponseWriter) bool {
	go f_log_db(uid, 0, url)
	tx, err := db.Begin()
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return false
	}
	result, err := tx.Exec("call set_url(?,?)", uid, url)
	e := tx.Commit()
	if e != nil {
		_ = tx.Rollback()
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return false
	}
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return false
	}
	affected, err := result.RowsAffected()
	if err != nil || affected != 1 {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return false
	}
	go f_send(uid, url)
	return true
}

// *handler func
func f_login(w http.ResponseWriter, r *http.Request) {
	body, err := f_readBody(r)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_READ_BODY, 0))
		return
	}
	loginData := &HandlerLoginData{}
	err = json.Unmarshal(body, loginData)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
	}
	if loginData.Name == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_USERNAME, 0))
		return
	}
	if loginData.Password == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_PASSWORD, 0))
		return
	}
	nameLen := utf8.RuneCountInString(loginData.Name)
	if nameLen < 1 || nameLen > 18 {
		fmt.Fprint(w, simpleJsonMsg(ERR_USERNAME_LENGTH, 0))
		return
	}
	passwordLen := utf8.RuneCountInString(loginData.Password)
	if passwordLen < 6 || passwordLen > 18 {
		fmt.Fprint(w, simpleJsonMsg(ERR_PASSWORD_LENGTH, 0))
		return
	}
	rows, err := db_query("SELECT 1 FROM user where name = ? LIMIT 1", loginData.Name)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	if !rows.Next() {
		fmt.Fprint(w, simpleJsonMsg(ERR_USER_NOT_EXIST, 0))
		return
	} else {
		rows.Close()
	}
	rows, err = db_query("SELECT id FROM user where name = ? AND password = ? LIMIT 1", loginData.Name, b64encode(loginData.Password))
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	uid := -1
	if rows.Next() {
		defer rows.Close()
		if err = rows.Scan(&uid); err != nil {
			fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
			return
		}
		token, err := createToken(uid)
		if err != nil {
			fmt.Println(err)
			fmt.Fprint(w, simpleJsonMsg(ERR_UNKNOWN, 0))
		} else {
			ck := &http.Cookie{
				Name:   "token",
				Value:  token,
				Path:   "/",
				MaxAge: 86400,
			}
			http.SetCookie(w, ck)
			fmt.Fprint(w, simpleJsonMsg("success", 1))
		}
	} else {
		fmt.Fprint(w, simpleJsonMsg(ERR_WRONG_PASSWORD, 0))
	}
}

func f_cookieLogin(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_cookieGetUid(r)
	if valid {
		// 刷新cookie时间
		token, err := createToken(uid)
		if err != nil {
			fmt.Println(err)
			fmt.Fprint(w, simpleJsonMsg(ERR_UNKNOWN, 0))
		} else {
			ck := &http.Cookie{
				Name:   "token",
				Value:  token,
				Path:   "/",
				MaxAge: 86400,
			}
			http.SetCookie(w, ck)
			fmt.Fprint(w, simpleJsonMsg("success", 1))
		}
	} else {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
	}
}

func f_register(w http.ResponseWriter, r *http.Request) {
	body, err := f_readBody(r)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_READ_BODY, 0))
		return
	}
	data := &HandlerRegisterData{}
	err = json.Unmarshal(body, data)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	if data.Key != "789456" {
		fmt.Fprint(w, simpleJsonMsg(ERR_KEY, 0))
		return
	}
	if data.Name == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_USERNAME, 0))
		return
	}
	if data.Password == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_PASSWORD, 0))
		return
	}
	nameLen := utf8.RuneCountInString(data.Name)
	if nameLen < 1 || nameLen > 18 {
		fmt.Fprint(w, simpleJsonMsg(ERR_USERNAME_LENGTH, 0))
		return
	}
	passwordLen := utf8.RuneCountInString(data.Password)
	if passwordLen < 6 || passwordLen > 18 {
		fmt.Fprint(w, simpleJsonMsg(ERR_PASSWORD_LENGTH, 0))
		return
	}
	if data.Password2 == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_PASSWORD2, 0))
		return
	}
	if data.Password != data.Password2 {
		fmt.Fprint(w, simpleJsonMsg(ERR_DIFFERENT_PASSWORD, 0))
		return
	}
	// tx, err := db.Begin()
	// result, err := db_exec("insert into `user`(`name`,`password`) select ?,? from `user` where not exists (select 1 from `user` where `name`=?) LIMIT 1", data.Name, b64encode(data.Password), data.Name)
	rows, err := db.Query("call user_register(?,?)", data.Name, b64encode(data.Password))
	// tx.Commit()
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	uid := -1
	if rows.Next() {
		// 有结果返回，则添加用户成功
		rows.Scan(&uid)
	} else {
		fmt.Fprint(w, simpleJsonMsg(ERR_USER_EXIST, 0))
		return
	}
	// rowsChange, err := result.RowsAffected()
	// if err != nil {
	// 	fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
	// 	return
	// }
	// // 无行更改，则用户已存在
	// if rowsChange == 0 {
	// 	fmt.Fprint(w, simpleJsonMsg(ERR_USER_EXIST, 0))
	// 	return
	// }
	// uid, err := result.LastInsertId()
	// if err != nil {
	// 	fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
	// 	return
	// }

	token, err := createToken(int(uid))
	if err != nil {
		fmt.Println(err)
		fmt.Fprint(w, simpleJsonMsg(ERR_UNKNOWN, 0))
	} else {
		ck := &http.Cookie{
			Name:   "token",
			Value:  token,
			Path:   "/",
			MaxAge: 86400,
		}
		http.SetCookie(w, ck)
		fmt.Fprint(w, simpleJsonMsg("success", 1))
	}
}

func f_getUserInfo(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_cookieGetUid(r)
	if !valid {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	rows, err := db_query("select `name` from `user` where id = ? LIMIT 1", uid)
	defer rows.Close()
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	if !rows.Next() {
		fmt.Fprint(w, simpleJsonMsg(ERR_USER_NOT_EXIST, 0))
		return
	}
	userInfo := &HandlerUserInfo{}
	if err = rows.Scan(&userInfo.Name); err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	msg := &MsgInterface{
		Success: 1,
		Msg:     userInfo,
	}
	j, err := json.Marshal(msg)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	fmt.Fprint(w, string(j))
}

func f_setUrl(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_cookieGetUid(r)
	if !valid {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	body, err := f_readBody(r)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_READ_BODY, 0))
		return
	}
	data := &HandlerSetUrl{}
	err = json.Unmarshal(body, data)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	if data.Url == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_URL, 0))
		return
	}
	rows, err := db_query("select status from url where uid = ?", uid)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	defer rows.Close()
	if rows.Next() { // 提交过URL
		status := -1
		rows.Scan(&status)
		switch status {
		case 0: // 请求中，不允许再次提交
			fmt.Fprint(w, simpleJsonMsg(ERR_REQUESTING, 0))
			return
		default: // 成功，失败，其他
			succ := f_sendReq(uid, data.Url, w)
			if !succ {
				return
			}
			fmt.Fprint(w, simpleJsonMsg("success", 1))
			return
		}
	} else { // 没有提交过URL
		succ := f_sendReq(uid, data.Url, w)
		if !succ {
			return
		}
		fmt.Fprint(w, simpleJsonMsg("success", 1))
	}
}

func f_getUrl(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_cookieGetUid(r)
	if !valid {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	rows, err := db_query("select `url`, `status`, `msg` from `url` where `uid` = ?", uid)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	defer rows.Close()
	if rows.Next() {
		data := &HandlerGetUrl{}
		rows.Scan(&data.Url, &data.Status, &data.Msg)
		msg := &MsgInterface{
			Success: 1,
			Msg:     data,
		}
		j, err := json.Marshal(msg)
		if err != nil {
			fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
			return
		}
		fmt.Fprint(w, string(j))
	} else {
		fmt.Fprint(w, simpleJsonMsg(ERR_URL_NOT_EXISTS, -1))
	}
}

func f_setKey(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_cookieGetUid(r)
	if !valid {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	body, err := f_readBody(r)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_READ_BODY, 0))
		return
	}
	data := &HandlerKey{}
	err = json.Unmarshal(body, data)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	if data.AK == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_AK, 0))
		return
	}
	if data.SK == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_SK, 0))
		return
	}
	go f_log_db(uid, 3, data.AK+" - "+data.SK)
	tx, err := db.Begin()
	result, err := tx.Exec("call set_key(?,?,?)", uid, data.AK, data.SK)
	e := tx.Commit()
	if e != nil {
		_ = tx.Rollback()
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	affected, err := result.RowsAffected()
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	if affected == 0 {
		fmt.Fprint(w, simpleJsonMsg(ERR_AKSK_NO_CHANGE, -1))
		return
	}

	fmt.Fprint(w, simpleJsonMsg("success", 1))
}

func f_getKey(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_cookieGetUid(r)
	if !valid {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	rows, err := db_query("select `ak`, `sk` from `key` where `uid` = ?", uid)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	defer rows.Close()
	if rows.Next() {
		data := &HandlerKey{}
		rows.Scan(&data.AK, &data.SK)
		msg := &MsgInterface{
			Success: 1,
			Msg:     data,
		}
		j, err := json.Marshal(msg)
		if err != nil {
			fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
			return
		}
		fmt.Fprint(w, string(j))
	} else {
		fmt.Fprint(w, simpleJsonMsg(ERR_AKSK_NOT_EXISTS, -1))
	}
}

func f_getLog(w http.ResponseWriter, r *http.Request) {
	_, valid := f_cookieGetUid(r)
	if !valid {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	fmt.Fprint(w, logData)
}

// func f_getLogAdmin(w http.ResponseWriter, r *http.Request) {
// 	_, valid := f_cookieGetUid(r)
// 	if !valid {
// 		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
// 		return
// 	}
// 	fmt.Fprint(w, "")
// }

func f_getLogDetails(w http.ResponseWriter, r *http.Request) {
	_, valid := f_cookieGetUid(r)
	if !valid {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	fmt.Fprint(w, logDetail)
}

func f_adminLogin(w http.ResponseWriter, r *http.Request) {
	body, err := f_readBody(r)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_READ_BODY, 0))
		return
	}
	data := &HandlerAdminLogin{}
	err = json.Unmarshal(body, data)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	if data.Key == "" {
		fmt.Fprint(w, simpleJsonMsg(ERR_EMPTY_KEY, 0))
		return
	}
	if data.Key != "adminkey" {
		fmt.Fprint(w, simpleJsonMsg(ERR_WRONG_KEY, 0))
		return
	}

	token, err := createToken(-1)
	if err != nil {
		fmt.Println(err)
		fmt.Fprint(w, simpleJsonMsg(ERR_UNKNOWN, 0))
	} else {
		ck := &http.Cookie{
			Name:   "admin_token",
			Value:  token,
			Path:   "/",
			MaxAge: 86400,
		}
		http.SetCookie(w, ck)
		fmt.Fprint(w, simpleJsonMsg("success", 1))
	}
}

func f_adminGetData(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_adminCookieGetUid(r)
	if !valid || uid != -1 {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	body, err := f_readBody(r)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_READ_BODY, 0))
		return
	}
	reqData := &HandlerAdminGetDataRequest{}
	err = json.Unmarshal(body, reqData)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	if reqData.Page <= 0 {
		reqData.Page = 1
	}
	if reqData.Length <= 0 {
		reqData.Length = 10
	}
	rtnData := &HandlerAdminDataReturn{}
	rows, err := db_query("call get_log_admin(?,?)", reqData.Page, reqData.Length)
	defer rows.Close()
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	if rows.Next() {
		rows.Scan(&rtnData.Count)
	}
	if !rows.NextResultSet() {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	data := []*HandlerAdminGetData{}
	for rows.Next() {
		d := &HandlerAdminGetData{}
		err = rows.Scan(&d.Time, &d.Name, &d.Type, &d.Msg)
		if err != nil {
			fmt.Println("admin get log error")
			fmt.Println(err)
		}
		data = append(data, d)
	}
	rtnData.Data = data
	rtn := &MsgInterface{}
	rtn.Success = 1
	rtn.Msg = rtnData
	j, err := json.Marshal(rtn)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	fmt.Fprint(w, string(j))

}

func f_adminCookieLogin(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_adminCookieGetUid(r)
	if valid && uid == -1 {
		// 刷新cookie时间
		token, err := createToken(uid)
		if err != nil {
			fmt.Println(err)
			fmt.Fprint(w, simpleJsonMsg(ERR_UNKNOWN, 0))
		} else {
			ck := &http.Cookie{
				Name:   "admin_token",
				Value:  token,
				Path:   "/",
				MaxAge: 86400,
			}
			http.SetCookie(w, ck)
			fmt.Fprint(w, simpleJsonMsg("success", 1))
		}
	} else {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
	}
}

func f_adminGetKey(w http.ResponseWriter, r *http.Request) {
	uid, valid := f_adminCookieGetUid(r)
	if !valid || uid != -1 {
		fmt.Fprint(w, simpleJsonMsg(ERR_TOKEN, 0))
		return
	}
	body, err := f_readBody(r)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_READ_BODY, 0))
		return
	}
	reqData := &HandlerGetKeyReq{}
	err = json.Unmarshal(body, &reqData)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	rows, err := db_query("select UNIX_TIMESTAMP(`time`), `admin_msg` from `log` where `type` = 3 AND `uid` = ?", reqData.Id)
	defer rows.Close()
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_DB, 0))
		return
	}
	arr := []*HandlerGetKeyData{}
	for rows.Next() {
		d := &HandlerGetKeyData{}
		err = rows.Scan(&d.Time, &d.Msg)
		if err != nil {
			fmt.Println("get key err")
			fmt.Println(err)
		}
		arr = append(arr, d)
	}
	rtn := &MsgInterface{
		Success: 1,
		Msg:     arr,
	}
	j, err := json.Marshal(rtn)
	if err != nil {
		fmt.Fprint(w, simpleJsonMsg(ERR_LOAD_JSON, 0))
		return
	}
	fmt.Fprint(w, string(j))

}