package v1

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"reflect"
	"strconv"
	"strings"
	"time"

	"github.com/IceWhaleTech/CasaOS/model"
	"github.com/IceWhaleTech/CasaOS/pkg/config"
	"github.com/IceWhaleTech/CasaOS/pkg/utils/file"
	oasis_err2 "github.com/IceWhaleTech/CasaOS/pkg/utils/oasis_err"
	"github.com/IceWhaleTech/CasaOS/service"
	model2 "github.com/IceWhaleTech/CasaOS/service/model"
	"github.com/IceWhaleTech/CasaOS/types"
	"github.com/gin-gonic/gin"
	uuid "github.com/satori/go.uuid"
)

func PersonTest(c *gin.Context) {
	token := c.Query("token")
	_, err := uuid.FromString(token)
	fmt.Println(err)

	//service.MyService.Person().GetPersionInfo("fb2333a1-72b2-4cb4-9e31-61ccaffa55b9")

	msg := model.MessageModel{}
	msg.Type = types.PERSONHELLO
	msg.Data = ""
	msg.From = config.ServerInfo.Token
	msg.To = token
	msg.UUId = uuid.NewV4().String()

	dd, err := service.Dial(msg, true)
	if err == nil {
		fmt.Println(err)
	}
	fmt.Println(dd)
	user := service.MyService.Casa().GetUserInfoByShareId(token)
	if reflect.DeepEqual(user, model.UserInfo{}) {
		fmt.Println("空数据")
	}
	fmt.Println(user)
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary Retry the file that failed to download
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Param  uui path string true "download uuid"
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/refile/{uuid} [get]
func GetPersonReFile(c *gin.Context) {

	uid := c.Param("uuid")
	_, err := uuid.FromString(uid)
	if err != nil {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}

	task := service.MyService.Download().GetDownloadById(uid)
	if reflect.DeepEqual(task, model2.PersonDownloadDBModel{}) {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_REMOTE_ERROR, Message: oasis_err2.GetMsg(oasis_err2.PERSON_REMOTE_ERROR)})
		return
	}
	token := task.From
	if _, ok := service.UDPAddressMap[token]; !ok {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_REMOTE_ERROR, Message: oasis_err2.GetMsg(oasis_err2.PERSON_REMOTE_ERROR)})
		return
	}

	m := model.MessageModel{}
	m.Data = task.Path
	m.From = config.ServerInfo.Token
	m.To = token
	m.Type = types.PERSONDOWNLOAD
	m.UUId = uid
	go service.Dial(m, false)

	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary download file
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Param  share_id query string true "opponent share_id"
// @Param  path query string true "file path"
// @Param  file_name query string true "file name"
// @Param  local_path query string true "local_path"
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/file [get]
func GetPersonFile(c *gin.Context) {

	path := c.Query("path")
	localPath := c.Query("local_path")
	token := c.Query("share_id")
	fileName := c.Query("file_name")
	_, err := uuid.FromString(token)
	if len(path) == 0 || err != nil || len(localPath) == 0 || len(fileName) == 0 {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}
	if file.CheckNotExist(localPath) {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.DIR_NOT_EXISTS, Message: oasis_err2.GetMsg(oasis_err2.DIR_NOT_EXISTS)})
		return
	}
	if _, ok := service.UDPAddressMap[token]; !ok {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_REMOTE_ERROR, Message: oasis_err2.GetMsg(oasis_err2.PERSON_REMOTE_ERROR)})
		return
	}

	if _, ok := service.UDPAddressMap[token]; !ok {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_REMOTE_ERROR, Message: oasis_err2.GetMsg(oasis_err2.PERSON_REMOTE_ERROR)})
		return
	}

	// task id
	uuid := uuid.NewV4().String()

	task := model2.PersonDownloadDBModel{}
	task.UUID = uuid
	task.Name = fileName
	task.Length = 0
	task.From = token
	task.Path = path
	task.Size = 0
	task.State = types.DOWNLOADAWAIT
	task.Created = time.Now().Unix()
	task.Type = 0
	task.LocalPath = localPath
	if service.MyService.Download().GetDownloadListByPath(task) > 0 {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_EXIST_DOWNLOAD, Message: oasis_err2.GetMsg(oasis_err2.PERSON_EXIST_DOWNLOAD)})
		return
	}
	service.MyService.Download().AddDownloadTask(task)

	m := model.MessageModel{}
	m.Data = path
	m.From = config.ServerInfo.Token
	m.To = token
	m.Type = types.PERSONDOWNLOAD
	m.UUId = uuid
	go service.Dial(m, false)

	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary delete download file records
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Param  uuid path string true "download uuid"
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/file/{uuid} [delete]
func DeletePersonDownloadFile(c *gin.Context) {

	id := c.Param("uuid")
	_, err := uuid.FromString(id)
	if err != nil {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}

	task := service.MyService.Download().GetDownloadById(id)
	if task.State == types.DOWNLOADING {
		m := model.MessageModel{}
		m.Data = ""
		m.From = config.ServerInfo.Token
		m.To = task.From
		m.Type = types.PERSONCANCEL
		m.UUId = task.UUID
		service.CancelList[task.UUID] = task.UUID
		service.Dial(m, false)
	}
	service.MyService.Download().DelDownload(id)

	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary Get file download list
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Param  state query int false "wait:0,downloading:1,pause:2,finish:3,error:4,finished:5" Enums(0,1,2,3,4,5)
// @Security ApiKeyAuth
// @Success 200 {object} []model2.PersonDownloadDBModel
// @Router /person/list [get]
func GetPersonDownloadList(c *gin.Context) {
	state := c.DefaultQuery("state", "")
	list := service.MyService.Download().GetDownloadListByState(state)
	//if it is  downloading, it need to add 'already'
	for i := 0; i < len(list); i++ {
		if list[i].State == types.DOWNLOADING {
			tempDir := config.AppInfo.RootPath + "/temp" + "/" + list[i].UUID
			files, err := ioutil.ReadDir(tempDir)
			if err == nil {
				list[i].Already = len(files)
			}
		}
		list[i].Duration = time.Now().Unix() - list[i].Created
	}
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS), Data: list})
}

// @Summary edit friend's remarks
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Param remarks formData string true "remarks name"
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/remarks/{shareid} [put]
func PutPersonRemarks(c *gin.Context) {
	token := c.Param("shareid")
	_, err := uuid.FromString(token)
	mark := c.PostForm("remarks")
	if err != nil || len(mark) == 0 {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}
	friend := model2.FriendModel{}
	friend.Token = token
	friend.Mark = mark
	service.MyService.Friend().EditFriendMark(friend)
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary get my friend list
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Security ApiKeyAuth
// @Success 200 {object}  []model2.FriendModel
// @Router /person/users [get]
func GetPersonFriend(c *gin.Context) {
	list := service.MyService.Friend().GetFriendList()
	for i := 0; i < len(list); i++ {
		if v, ok := service.UDPAddressMap[list[i].Token]; ok && len(v) > 0 {
			list[i].OnLine = true
		}
	}
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS), Data: list})
}

// @Summary add friend
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/user/{shareids} [post]
func PostAddPersonFriend(c *gin.Context) {
	token := c.Param("shareids")
	tokenList := strings.Split(token, ",")

	for _, v := range tokenList {
		_, err := uuid.FromString(v)
		if err != nil {
			c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
			return
		}

		if v == config.ServerInfo.Token {
			c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_MYSELF, Message: oasis_err2.GetMsg(oasis_err2.PERSON_MYSELF)})
			return
		}

		udb := service.MyService.Friend().GetFriendById(model2.FriendModel{Token: v})
		if !reflect.DeepEqual(udb, model2.FriendModel{Token: v}) {
			c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_EXIST_FRIEND, Message: oasis_err2.GetMsg(oasis_err2.PERSON_EXIST_FRIEND)})
			return
		}

		user := service.MyService.Casa().GetUserInfoByShareId(v)
		if reflect.DeepEqual(user, model.UserInfo{}) {
			c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_NOT_EXIST_USER, Message: oasis_err2.GetMsg(oasis_err2.PERSON_NOT_EXIST_USER)})
			return
		}

		message := model.MessageModel{}
		message.Type = types.PERSONCONNECTION
		message.Data = v
		message.From = config.ServerInfo.Token
		message.To = v
		message.UUId = uuid.NewV4().String()

		go service.Dial(message, true)

		friend := model2.FriendModel{}
		friend.Token = v
		friend.Avatar = user.Avatar
		friend.Block = false
		friend.NickName = user.NickName
		friend.Profile = user.Desc
		friend.Version = user.Version
		service.MyService.Friend().AddFriend(friend)
	}

	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary Get a list of directories
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Param  share_id query string true "Opponent share_id"
// @Param  path query string true "dir path"
// @Security ApiKeyAuth
// @Success 200 {object}  []model.Path
// @Router /person/directory [get]
func GetPersonDirectory(c *gin.Context) {
	path := c.Query("path")
	token := c.Query("share_id")
	_, err := uuid.FromString(token)
	if len(path) == 0 || err != nil {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}
	if _, ok := service.UDPAddressMap[token]; !ok {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.PERSON_REMOTE_ERROR, Message: oasis_err2.GetMsg(oasis_err2.PERSON_REMOTE_ERROR)})
		return
	}
	uuid := uuid.NewV4().String()
	m := model.MessageModel{}
	m.Data = path
	m.From = config.ServerInfo.Token
	m.To = token
	m.Type = types.PERSONDIRECTORY
	m.UUId = uuid
	result, err := service.Dial(m, false)
	if err != nil {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.ERROR, Message: oasis_err2.GetMsg(oasis_err2.ERROR), Data: err.Error()})
		return
	}
	dataModel := []model.Path{}
	if uuid == m.UUId {
		dataModelByte, _ := json.Marshal(result.Data)
		err := json.Unmarshal(dataModelByte, &dataModel)
		if err != nil {
			c.JSON(http.StatusOK, model.Result{Success: oasis_err2.ERROR, Message: oasis_err2.GetMsg(oasis_err2.ERROR), Data: err.Error()})
			return
		}
	}
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS), Data: dataModel})
}

// @Summary Modify the download storage directory
// @Produce  application/json
// @Accept  multipart/form-data
// @Tags person
// @Security ApiKeyAuth
// @Param path formData string true "path"
// @Success 200 {string} string "ok"
// @Router /person/down/dir [post]
func PostPersonDownDir(c *gin.Context) {

	downPath := c.PostForm("path")

	if len(downPath) == 0 {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}
	if file.CheckNotExist(downPath) {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.DIR_NOT_EXISTS, Message: oasis_err2.GetMsg(oasis_err2.DIR_NOT_EXISTS)})
		return
	}
	config.Cfg.Section("file").Key("DownloadDir").SetValue(downPath)
	config.Cfg.SaveTo(config.SystemConfigInfo.ConfigPath)
	config.FileSettingInfo.DownloadDir = downPath
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary Get the download storage directory
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/down/dir [get]
func GetPersonDownDir(c *gin.Context) {
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS), Data: config.FileSettingInfo.DownloadDir})
}

// @Summary Modify the shared directory
// @Produce  application/json
// @Accept  multipart/form-data
// @Tags person
// @Security ApiKeyAuth
// @Param share formData string true "share"
// @Success 200 {string} string "ok"
// @Router /person/share [post]
func PostPersonShare(c *gin.Context) {

	share := c.PostForm("share")

	if len(share) == 0 {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}

	var list []string
	json.Unmarshal([]byte(share), &list)

	if len(list) == 0 {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}
	for _, v := range list {
		if !file.Exists(v) {
			c.JSON(http.StatusOK, model.Result{Success: oasis_err2.FILE_ALREADY_EXISTS, Message: oasis_err2.GetMsg(oasis_err2.FILE_ALREADY_EXISTS)})
			return
		}
	}

	config.Cfg.Section("file").Key("ShareDir").SetValue(strings.Join(list, "|"))
	config.Cfg.SaveTo(config.SystemConfigInfo.ConfigPath)
	config.FileSettingInfo.ShareDir = list
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary Get the shared directory
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/share [get]
func GetPersonShare(c *gin.Context) {
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS), Data: config.FileSettingInfo.ShareDir})
}

// @Summary Modify disabled status
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Param block formData bool false "Disable or not,Default:false "
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/block/{shareid} [put]
func PutPersonBlock(c *gin.Context) {
	token := c.Param("shareid")
	_, err := uuid.FromString(token)
	block, _ := strconv.ParseBool(c.PostForm("block"))
	if err != nil {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}
	friend := model2.FriendModel{}
	friend.Token = token
	friend.Block = block
	service.MyService.Friend().EditFriendBlock(friend)
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary Delete my friend
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/user/{shareid} [delete]
func DeletePersonFriend(c *gin.Context) {
	token := c.Param("shareid")
	_, err := uuid.FromString(token)
	if err != nil {
		c.JSON(http.StatusOK, model.Result{Success: oasis_err2.INVALID_PARAMS, Message: oasis_err2.GetMsg(oasis_err2.INVALID_PARAMS)})
		return
	}
	friend := model2.FriendModel{}
	friend.Token = token

	service.MyService.Friend().DeleteFriend(friend)
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS)})
}

// @Summary Get public person
// @Produce  application/json
// @Accept application/json
// @Tags person
// @Security ApiKeyAuth
// @Success 200 {string} string "ok"
// @Router /person/public [delete]
func GetPersonPublic(c *gin.Context) {
	list := service.MyService.Casa().GetPersonPublic()
	c.JSON(http.StatusOK, model.Result{Success: oasis_err2.SUCCESS, Message: oasis_err2.GetMsg(oasis_err2.SUCCESS), Data: list})
}