package pcsg

import (
	"encoding/json"
	"errors"
	"eta/eta_email_analysis/global"
	"eta/eta_email_analysis/models/eta"
	"eta/eta_email_analysis/models/report"
	"eta/eta_email_analysis/utils"
	"eta/eta_email_analysis/utils/mail"
	"fmt"
	"github.com/emersion/go-imap"
	"github.com/emersion/go-imap/client"
	"log"
	"strings"
)

func Fix() {
	mailAddress := fmt.Sprintf("%s:%d", global.CONFIG.Email.Host, global.CONFIG.Email.Port)

	// 建立与 IMAP 服务器的连接
	c, err := client.DialTLS(mailAddress, nil)
	if err != nil {
		fmt.Printf("连接 IMAP 服务器失败: %+v \n", err)
		return
	}
	// 最后一定不要忘记退出登录
	defer func() {
		_ = c.Logout()
	}()

	// 登录
	if err = c.Login(global.CONFIG.Email.UserName, global.CONFIG.Email.Password); err != nil {
		fmt.Printf("邮箱[%s] 登录失败: %v \n", fmt.Sprintf("%s:%s", global.CONFIG.Email.UserName, mailAddress), err)
		return
	}
	// 列出当前邮箱中的文件夹
	mailboxes := make(chan *imap.MailboxInfo, 10)
	done := make(chan error, 1) // 记录错误的 chan
	go func() {
		done <- c.List("", "*", mailboxes)
	}()
	log.Println("-->当前邮箱的文件夹 Mailboxes:")

	var folderExists bool
	for m := range mailboxes {
		log.Println("* ", m.Name)
		if m.Name == global.CONFIG.Email.Folder {
			folderExists = true
		}
	}

	err = <-done
	if err != nil {
		global.LOG.Errorf("列出邮箱列表时，出现错误：%v \n", err)
		return
	}

	log.Println("-->列出邮箱列表完毕！")
	if !folderExists {
		err = errors.New(fmt.Sprintf("文件夹[%s] 不存在 \n", global.CONFIG.Email.Folder))
		return
	}

	// 选择指定的文件夹
	mbox, err := c.Select(global.CONFIG.Email.Folder, false)
	if err != nil {
		err = errors.New(fmt.Sprintf("选择邮件箱失败: %+v", err))
		return
	}
	//log.Printf("mbox %+v \n", mbox)
	log.Printf("当前文件夹[%s]中，总共有 %d 封邮件 \n", global.CONFIG.Email.Folder, mbox.Messages)
	if mbox.Messages == 0 {
		//log.Fatalf("当前文件夹[%s]中没有邮件", folder)
		return
	}

	list, err := report.GetNoSysUserNameOutsideReport()
	if err != nil {
		fmt.Println("获取没有用户的信息失败：", err)
		return
	}

	for _, v := range list {
		_, fromName, tmpErr := mail.ListenMailV2(c, v.EmailMessageUID)
		if tmpErr != nil {
			fmt.Println(v.Title, ",获取失败:", tmpErr)
			continue
		}
		v.SysUserName = fromName
		tmpErr = v.Update([]string{"SysUserName"})
		if tmpErr != nil {
			fmt.Println(v.Title, ",更新信息失败:", tmpErr)
			continue
		}
	}
}

func FixHistory() {
	list, err := report.GetMailOutsideReport()
	if err != nil {
		fmt.Println("获取没有分类的信息失败：", err)
		return
	}

	ruleJson, err := eta.GetBusinessConfByKey("MailCheckRule")
	if err != nil {
		global.FILE_LOG.Error("获取规则配置失败：%v", err)
		return
	}
	var ruleList []report.MailRule
	err = json.Unmarshal([]byte(ruleJson.ConfVal), &ruleList)
	if err != nil {
		global.FILE_LOG.Error("解析规则配置失败：%v", err)
		return
	}
	ruleMap := make(map[string]report.MailRule)
	for _, v := range ruleList {
		ruleMap[v.Rule] = v
	}

	classifyAll, e := report.GetClassifyAll()
	if e != nil {
		err = e
		global.FILE_LOG.Error("获取分类失败：", err)
		return
	}
	calssifyMap := make(map[int]*report.Classify)
	for _, v := range classifyAll {
		calssifyMap[v.Id] = v
	}

	for _, reportInfo := range list {
		for _, v := range ruleList {
			title := strings.ToLower(reportInfo.Title)
			rule := strings.ToLower(v.Rule)
			if strings.Contains(title, rule) {
				fmt.Println(reportInfo.Title, "匹配到规则：", v.Rule)
				reportInfo.Title = v.Title
				reportInfo.Abstract = v.Abstract
				reportInfo.ClassifyID = v.ClassifyId
				if calssifyMap[v.ClassifyId] != nil {
					reportInfo.ClassifyName = calssifyMap[v.ClassifyId].ClassifyName
				}
				// 特殊规则
				if strings.Contains(title, "海外分公司市场信息月报") || strings.Contains(title, "区域市场信息月报") {
					if reportInfo.SysUserName == "report.pcanalyst00@petrochina-usa.com" {
						v.Author = "PCI"
					} else {
						v.Author = reportInfo.SysUserName
					}
				}
				if strings.Contains(v.Author, "@") {
					sysUser, tmpErr := eta.GetSysUserByEmail(v.Author)
					if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
						err = tmpErr
						return
					}
					if sysUser.AdminId > 0 {
						reportInfo.SysUserID = sysUser.AdminId
						reportInfo.SysUserName = sysUser.RealName
					} else {
						reportInfo.SysUserName = v.Author
					}
				} else {
					reportInfo.SysUserName = v.Author
				}
				err = reportInfo.Update([]string{"Title", "Abstract", "ClassifyID", "ClassifyName", "SysUserID", "SysUserName"})
				if err != nil {
					fmt.Println("更新失败：", err)
					return
				}
				fmt.Println(reportInfo.Title, "更新成功")
				break
			}
		}
		if strings.Contains(reportInfo.Title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ") {
			reportInfo.Title = strings.Replace(reportInfo.Title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ", "", -1)
			err = reportInfo.Update([]string{"Title"})
			if err != nil {
				fmt.Println("更新失败：", err)
				return
			}
			fmt.Println(reportInfo.Title, "去除前缀成功")
		}
	}
}

func FixHistory2() {
	list, err := report.GetMailOutsideReportHistory()
	if err != nil {
		fmt.Println("获取没有分类的信息失败：", err)
		return
	}
	fmt.Println("报告数量：", len(list))
	ruleJson, err := eta.GetBusinessConfByKey("MailCheckRule")
	if err != nil {
		global.FILE_LOG.Error("获取规则配置失败：%v", err)
		return
	}
	var ruleList []report.MailRule
	err = json.Unmarshal([]byte(ruleJson.ConfVal), &ruleList)
	if err != nil {
		global.FILE_LOG.Error("解析规则配置失败：%v", err)
		return
	}
	fmt.Println("规则数量：", len(ruleList))


	for _, reportInfo := range list {
		fmt.Println("标题：",reportInfo.Title)
		fmt.Println("作者：",reportInfo.SysUserName)
		// 特殊规则
		if strings.Contains(reportInfo.Title, "海外分公司市场信息月报") || strings.Contains(reportInfo.Title, "区域市场信息月报") {
			if reportInfo.SysUserName == "report.pcanalyst00@petrochina-usa.com" {
				reportInfo.SysUserName = "PCI"
				err = reportInfo.Update([]string{"SysUserName"})
				if err != nil {
					fmt.Println("更新失败：", err)
					return
				}
				fmt.Println(reportInfo.Title, "更新成功")
				continue
			} else if strings.Contains(reportInfo.SysUserName, "@") {
				sysUser, tmpErr := eta.GetSysUserByEmail(reportInfo.SysUserName)
				if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
					err = tmpErr
					return
				}
				if sysUser.AdminId > 0 {
					fmt.Println(reportInfo.SysUserName," 有对应用户:", sysUser.RealName)
					reportInfo.SysUserID = sysUser.AdminId
					reportInfo.SysUserName = sysUser.RealName
				}
				fmt.Println("无对应用户")
				err = reportInfo.Update([]string{"SysUserID", "SysUserName"})
				if err != nil {
					fmt.Println("更新失败：", err)
					return
				}
				fmt.Println(reportInfo.Title, "更新成功")
			}
		}
	}
}