package service

import (
	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/bhomedbapi.git"
	"basic.com/valib/logger.git"
	"encoding/json"
	"errors"
	"vamicro/stack-service/models"
	"vamicro/stack-service/vo"
)

type FileAnalysisService struct {
	Bk bhomeclient.Broker
}

const (
	Sort_Up   = 1
	Sort_Down = 2
)

func (fas *FileAnalysisService) FindAllByPage(fileName string, fType int, page int, size int, stackId string) (result vo.PageResult) {

	var model models.FileAnalysis
	result.Total = model.Total(fileName, fType, stackId)
	var fileList = make([]vo.FileIfRule, 0)

	if result.Total > 0 {
		arr, _ := model.FindAllByPage(fileName, fType, page, size, stackId)
		if arr != nil {
			var crApi bhomedbapi.CameraRuleApi
			for _, f := range arr {
				file := vo.FileIfRule{}
				file.FileAnalysis = f
				if crApi.ExistRunningTask(f.Id) {
					file.HasRule = true
				} else {
					file.HasRule = false
				}
				fileList = append(fileList, file)
			}
		}
	}
	result.DataList = fileList
	return result
}

func (fas *FileAnalysisService) GetAnalysisFiles() (fileList []models.FileAnalysis, err error) {
	var model models.FileAnalysis
	var crApi bhomedbapi.CameraRuleApi
	arr, e := model.FindAnalysisFiles()
	if e == nil && arr != nil {
		for _, f := range arr {
			if crApi.ExistRunningTask(f.Id) {
				fileList = append(fileList, f)
			}
		}
		return fileList, nil
	}
	return nil, e
}

func (fas *FileAnalysisService) Add(fa models.FileAnalysis) bool {
	if fa.Add() {
		dbMsg := protomsg.DbChangeMessage{
			Table:  protomsg.TableChanged_T_File,
			Id:     fa.Id,
			Action: protomsg.DbAction_Insert,
		}
		pb, _ := json.Marshal(dbMsg)
		fas.Bk.Publish(ProcName, pb)
		return true
	}
	return false
}

func (fas *FileAnalysisService) Rename(id, name string) bool {
	var fa models.FileAnalysis
	if fa.Rename(id, name) {
		dbMsg := protomsg.DbChangeMessage{
			Table:  protomsg.TableChanged_T_File,
			Id:     id,
			Action: protomsg.DbAction_Update,
		}
		pb, _ := json.Marshal(dbMsg)
		fas.Bk.Publish(ProcName, pb)

		return true
	}
	return false
}

func (fas *FileAnalysisService) Move(id, stackId string) bool {
	var fa models.FileAnalysis
	if fa.Move(id, stackId) {
		dbMsg := protomsg.DbChangeMessage{
			Table:  protomsg.TableChanged_T_File,
			Id:     id,
			Action: protomsg.DbAction_Update,
		}
		pb, _ := json.Marshal(dbMsg)
		fas.Bk.Publish(ProcName, pb)

		return true
	}
	return false
}

func (fas *FileAnalysisService) UpdateProgress(ids []string, progress int) bool {
	var file models.FileAnalysis
	return file.UpdateProgress(ids, progress)
}

func (fas *FileAnalysisService) UpdateStatus(ids []string, status int) bool {
	for _, id := range ids {
		var tmpFile models.FileAnalysis
		_, err := tmpFile.SelectById(id)
		if err != nil {
			logger.Error("fail to tmpFile.SelectById(id)", id)
			continue
		}
		logger.Debug("updateStatus", id)
		flag := false
		if status == 0 && tmpFile.Status == bhomeclient.File_Status_Wait {
			if tmpFile.UpdateStatus(id, bhomeclient.File_Status_Pause) {
				flag = true
			}
		} else if status == 1 && tmpFile.Status != bhomeclient.File_Status_Doing {
			if tmpFile.UpdateStatus(id, bhomeclient.File_Status_Wait) {
				flag = true
			}
		}
		if flag {
			dbMsg := protomsg.DbChangeMessage{
				Table:  protomsg.TableChanged_T_File,
				Id:     id,
				Action: protomsg.DbAction_Update,
			}
			pb, _ := json.Marshal(dbMsg)
			fas.Bk.Publish(ProcName, pb)
		}
	}
	return true
}

func (fas *FileAnalysisService) Delete(arg *vo.IdArrVo) bool {
	var file models.FileAnalysis
	logger.Debug("argIds", arg.Ids, "argIdsLength", len(arg.Ids))
	for _, id := range arg.Ids {
		//正在处理的文件不允许删除
		//rows, err := file.SelectById(id)
		//if err == nil && rows > 0 {
		//	//if file.Status == bhomeclient.File_Status_Doing {
		//	//	continue
		//	//} else {
		//	//}
		//}
		file.UpdateStatus(id, -1)
	}
	return true
}

func (fas *FileAnalysisService) SortFile(sortArg *vo.SortVo) bool {
	var err error
	tx := models.GetDB().Begin()
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()

	var file models.FileAnalysis
	rows, _ := file.SelectById(sortArg.Id)
	if rows > 0 {
		if sortArg.Direct == Sort_Up {
			if file.Sort > 1 {
				preSort := file.Sort - 1
				var preFile models.FileAnalysis
				pr, _ := preFile.FindBySort(preSort)
				if pr > 0 {
					if preFile.Status == bhomeclient.File_Status_Doing {
						err = errors.New("cannot be pre by doing file")
						return false
					}
					err = tx.Exec("update file_analysis set sort=? where id=?", preSort, file.Id).Error
					if err != nil {
						return false
					}
					err = tx.Exec("update file_analysis set sort=? where id=?", file.Sort, preFile.Id).Error
					if err != nil {
						return false
					}
				}
			}
		} else if sortArg.Direct == Sort_Down {
			if file.Status == bhomeclient.File_Status_Doing {
				err = errors.New("doing file cannot be sort down")
				return false
			}
			var maxTmp models.FileAnalysis
			mr, _ := maxTmp.GetMaxSortFile(file.StackId)
			if mr > 0 {
				if maxTmp.Id != sortArg.Id {
					nextSort := file.Sort + 1
					var nextFile models.FileAnalysis
					nr, _ := nextFile.FindBySort(nextSort)
					if nr > 0 {
						err = tx.Exec("update file_analysis set sort=? where id=?", nextSort, file.Id).Error
						if err != nil {
							return false
						}
						err = tx.Exec("update file_analysis set sort=? where id=?", file.Sort, nextFile.Id).Error
						if err != nil {
							return false
						}
					}
				}
			}
		}
	}
	tx.Commit()

	return true
}

func (fas *FileAnalysisService) FindByStackId(stackId string, typ int, name string, page int, size int) (result vo.PageResult) {
	var faE models.FileAnalysis
	result.Total = faE.Total(name, typ, stackId)
	if result.Total > 0 {
		arr, _ := faE.FindByStackId(stackId, typ, name, page, size)
		result.DataList = arr
	} else {
		result.DataList = []models.FileAnalysis{}
	}

	return result
}