package report

import (
	"encoding/json"
	"eta_mini_ht_api/common/component/es"
	logger "eta_mini_ht_api/common/component/log"
	"eta_mini_ht_api/common/utils/page"
	"eta_mini_ht_api/models"
	"eta_mini_ht_api/models/eta"
	etaDao "eta_mini_ht_api/models/eta"
	reportDao "eta_mini_ht_api/models/report"
	"strconv"
	"time"
)

const (
	indexName = "report_index"

	SourceETA = "ETA"
	SourceHT  = "HT"

	DESC models.Order = "desc"
	ASC  models.Order = "asc"

	ESIndex       = "report_index"
	ESColumn      = "abstract"
	ESRangeColumn = "report_id"
)

var (
	sortField = []string{"_score:desc"}
)

func elastic() *es.ESClient {
	return es.GetInstance()
}

// ESReport Report ES研报mapping
type ESReport struct {
	ReportID      int                    `json:"report_id"`
	OrgId         int                    `json:"org_id"`
	Author        string                 `json:"author"`
	Source        reportDao.ReportSource `json:"source"`
	Abstract      string                 `json:"abstract"`
	Status        reportDao.ReportStatus `json:"status"`
	PublishedTime string                 `json:"published_time"`
}

type ReportDTO struct {
	ReportID        int         `json:"report_id"`
	OrgId           int         `json:"org_id"`
	Title           string      `json:"title"`
	Author          string      `json:"author"`
	Source          string      `json:"source"`
	Abstract        string      `json:"abstract"`
	PublishedTime   string      `json:"published_time"`
	PermissionNames interface{} `json:"permissionNames,omitempty"`
	Highlight       []string    `json:"highlight,omitempty"`
}

type PermissionDTO struct {
	ID       int
	Name     string
	ParentID int
}

type RecordCountDTO struct {
	UserId     int
	Mobile     string
	ReportId   int
	IpAddress  string
	Location   string
	Referer    string
	Additional string
}

func GetTotalPageCount() (total int64) {
	return reportDao.GetTotalPageCount()
}
func SearchMaxReportId() (reportId int64) {
	sortField = []string{"report_id:desc"}
	request := matchAll(sortField)
	//同步es
	re, err := elastic().Search(request)
	if err != nil {
		logger.Error("es:%v", err)
	}
	hits := elastic().GetSource(re.Hits)
	data := hits[0].Source
	report := ReportDTO{}
	err = json.Unmarshal(data, &report)
	if err != nil {
		logger.Error("获取当前最大研报id失败:%v", err)
		return 0
	}
	return int64(report.ReportID)
}

func SearchReportList(key string, from int, size int, max int64) (reports []ReportDTO, err error) {
	//同步es
	sorts := append(sortField, "report_id:desc")
	request := matchRange(key, from, size, max, sorts)
	re, err := elastic().Search(request)
	if err != nil {
		logger.Error("es:%v", err)
	}
	hits := elastic().GetSource(re.Hits)
	for _, hit := range hits {
		var content map[string][]string
		err = json.Unmarshal(hit.Highlight, &content)
		report := ReportDTO{}
		report.Highlight = content[ESColumn]
		err = json.Unmarshal(hit.Source, &report)
		if err != nil {
			logger.Error("解析研报数据失败:%v", err)
			continue
		}
		reports = append(reports, report)
	}
	return
}
func GetReportPage(pageInfo page.PageInfo) (list []ReportDTO, err error) {
	offset := page.StartIndex(pageInfo.Current, pageInfo.PageSize)
	reports, err := reportDao.GetReportPage(pageInfo.LatestId, pageInfo.PageSize, offset)
	if err == nil && reports != nil {
		for _, report := range reports {
			dto := convertReportDTO(report)
			list = append(list, dto)
		}
	}
	return
}
func getETAReportFirstPermissions(id int) (permissionDTOs []PermissionDTO) {
	classifyId, err := etaDao.GetReportClassifyById(id)
	if err != nil || classifyId == 0 {
		logger.Error("获取研报分类信息失败:%v", err)
		return
	}
	permissions, err := etaDao.GetFirstPermissionsByClassifyID(classifyId)
	if err != nil {
		logger.Error("获取研报一级品种信息失败:%v", err)
		return
	}
	for _, permission := range permissions {
		permissionDTOs = append(permissionDTOs, convertPermissionDTO(permission))
	}
	return
}
func (es ESReport) GetId() string {
	return strconv.Itoa(es.ReportID)
}
func GetETALatestReportId() (id int, err error) {
	return reportDao.GetETALatestReportId()
}

func SyncETAReportList(list []eta.ETAReport) (err error) {
	logger.Info("同步研报数量%d", len(list))
	var reports []reportDao.Report
	var esReports []es.ESBase
	for _, etaRp := range list {
		destRp := convertEtaReport(etaRp)
		reports = append(reports, destRp)
	}
	err = reportDao.BatchInsertReport(&reports)
	if err != nil {
		logger.Error("同步ETA研报失败:%v", err)
		return
	}
	for _, etaRp := range reports {
		esRp := convertEsReport(etaRp)
		esReports = append(esReports, esRp)
	}
	//同步es
	err = elastic().BulkInsert(indexName, esReports)
	if err != nil {
		logger.Error("同步ETA研报到es失败:%v", err)
		return
	}
	return
}

func GetListOrderByCondition(column string, limit int, order models.Order) (dtoList []ReportDTO, err error) {
	reports, err := reportDao.GetListOrderByCondition(column, limit, order)
	if err != nil {
		logger.Error("获取研报失败:%v", err)
		return
	}
	for _, report := range reports {
		dto := convertReportDTO(report)
		dtoList = append(dtoList, dto)
	}
	return
}

func GetListByCondition[T any](column string, ids []T) (dtoList []ReportDTO, err error) {
	var values []interface{}
	for _, id := range ids {
		values = append(values, id)
	}
	reports, err := reportDao.GetListByCondition(column, ids)
	if err != nil {
		logger.Error("获取研报失败:%v", err)
		return
	}
	for _, report := range reports {
		dto := convertReportDTO(report)
		dtoList = append(dtoList, dto)
	}
	return
}

func convertEtaReport(etaRp eta.ETAReport) reportDao.Report {
	return reportDao.Report{
		OrgID:         etaRp.ID,
		Title:         etaRp.Title,
		Abstract:      etaRp.Abstract,
		Author:        etaRp.Author,
		PublishedTime: etaRp.PublishTime,
		Source:        reportDao.SourceETA,
		Status:        reportDao.StatusInit,
	}
}
func convertEsReport(report reportDao.Report) ESReport {
	return ESReport{
		ReportID:      report.ID,
		OrgId:         report.OrgID,
		Author:        report.Author,
		Source:        report.Source,
		Abstract:      report.Abstract,
		Status:        report.Status,
		PublishedTime: report.PublishedTime,
	}
}

func convertReportDTO(report reportDao.Report) (reportDTO ReportDTO) {
	reportDTO = ReportDTO{
		ReportID:      report.ID,
		Title:         report.Title,
		OrgId:         report.OrgID,
		Author:        report.Author,
		Source:        string(report.Source),
		Abstract:      report.Abstract,
		PublishedTime: report.PublishedTime,
	}
	publishDate, err := time.Parse(time.DateTime, reportDTO.PublishedTime)
	if err == nil {
		reportDTO.PublishedTime = publishDate.Format(time.DateOnly)
	}
	return
}

func matchAll(sorts []string) (request *es.ESQueryRequest) {
	req := new(es.ESQueryRequest)
	return req.CreateESQueryRequest(ESIndex, "", "", 0, 1, sorts, es.MatchAll)
}

func matchRange(key string, from int, to int, max int64, sorts []string) (request *es.ESQueryRequest) {
	req := new(es.ESQueryRequest)
	return req.CreateESQueryRequest(ESIndex, ESColumn, key, from, to, sorts, es.Range).Range(0, max, ESRangeColumn)
}