package logic

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/pkg/es"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/es_service/approval/html"
	"go.uber.org/zap"
	"html/template"
	"strconv"
	"strings"

	"github.com/fonchain_enterprise/fonchain-main/api/approval"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/es_service/approval/model"

	"github.com/jinzhu/copier"
	"github.com/olivere/elastic/v7"
)

func BulkIndexApprovalInfo(index string, page, pageSize uint64) {
	var req approval.ListRequest
	req.Page = page
	req.PageSize = pageSize
	req.OrderBy = "desc"
	res, err := service.ApprovalProvider.MyWorkV2(context.Background(), &req)
	if err != nil {
		return
	}

	//_, err = es.ElasticClient.DeleteIndex(index).Do(context.Background())
	//if err != nil {
	//	fmt.Println("=======================  DeleteIndex  es  err =======================")
	//	fmt.Println("err : ", err.Error())
	//	fmt.Println("=======================  DeleteIndex  es  err =======================")
	//}

	// 判断 index 是否存在
	exists, err := es.ElasticClient.IndexExists(index).Do(context.Background())
	if err != nil {
		fmt.Println("=======================  IndexExists  es  err =======================")
		fmt.Println("err : ", err.Error())
		zap.L().Error("IndexExists es err", zap.Error(err))
		fmt.Println("=======================  IndexExists  es  err =======================")
		return
	}

	if !exists {
		result, err := es.ElasticClient.CreateIndex(index).BodyJson(model.ApprovalMapping).Do(context.Background())
		if err != nil {
			fmt.Println("=======================  CreateIndex  es  err =======================")
			fmt.Println("err : ", err.Error())
			zap.L().Error("CreateIndex es err", zap.Error(err))
			fmt.Println("=======================  CreateIndex  es  err =======================")
		}

		fmt.Println("=======================  CreateIndex  es  result =======================")
		fmt.Printf("%+v\n", result)
		fmt.Println("=======================  CreateIndex  es  result =======================")
	}

	// Bulk insert
	bulkRequest := es.ElasticClient.Bulk()
	for _, datum := range res.Data {
		//  组装数据
		esApproval := new(model.EsApproval)
		copyWithOptionErr := copier.CopyWithOption(&esApproval, datum, copier.Option{DeepCopy: true})
		if copyWithOptionErr != nil {
			fmt.Println("=======================  CopyWithOption  es  err =======================")
			fmt.Println("err : ", copyWithOptionErr.Error())
			zap.L().Error("CopyWithOption es err", zap.Error(copyWithOptionErr))
			fmt.Println("=======================  CopyWithOption  es  err =======================")
		}
		fmt.Println("=======================  CopyWithOption  es  result =======================")
		fmt.Printf("esApproval is :%+v\n", esApproval)
		fmt.Println("=======================  CopyWithOption  es  result =======================")
		if esApproval.ID == 0 {
			continue
		}
		fmt.Println("=======================  CopyWithOption  datum  result =======================")
		fmt.Printf("approval model is :%+v\n", datum)
		fmt.Println("=======================  CopyWithOption  datum  result =======================")
		copyUserWithOptionErr := copier.CopyWithOption(&esApproval.CopyUsers, datum.CopyUsers, copier.Option{DeepCopy: true})
		if copyUserWithOptionErr != nil {
			fmt.Println("=======================  CopyWithOption  es  err =======================")
			fmt.Println("err : ", copyUserWithOptionErr.Error())
			zap.L().Error("CopyWithOption es err", zap.Error(copyUserWithOptionErr))
			fmt.Println("=======================  CopyWithOption  es  err =======================")
		}
		customizeInfoWithOptionErr := copier.CopyWithOption(&esApproval.CustomizeInfo, datum.CustomizeInfo, copier.Option{DeepCopy: true})
		if customizeInfoWithOptionErr != nil {
			fmt.Println("=======================  CopyWithOption  es  err =======================")
			fmt.Println("err : ", customizeInfoWithOptionErr.Error())
			zap.L().Error("CopyWithOption es err", zap.Error(customizeInfoWithOptionErr))
			fmt.Println("=======================  CopyWithOption  es  err =======================")
		}
		//bt, _ := json.Marshal(esApproval)
		doc := elastic.NewBulkIndexRequest().Index(index).Id(fmt.Sprintf("%d", datum.ID)).Doc(esApproval)
		bulkRequest = bulkRequest.Add(doc)
	}

	bulkRequestResult, bulkRequestErr := bulkRequest.Refresh("true").Do(context.Background())
	if bulkRequestErr != nil {
		fmt.Println("=======================  put  es  err =======================")
		fmt.Printf("bulkRequest  err : %+v\n", bulkRequestErr.Error())
		zap.L().Error("put es err", zap.Error(bulkRequestErr))
		fmt.Println("=======================  put  es  err =======================")
	}
	fmt.Println("=======================  NewBulkUpdateRequest  es  result =======================")
	fmt.Printf("NewBulkUpdateRequest is :%+v\n", bulkRequestResult)
	/*for i := 0; i < len(bulkRequestResult.Items); i++ {
		for k, item := range bulkRequestResult.Items[i] {
			fmt.Printf("NewBulkUpdateRequest Items k is :%+v\n", k)
			fmt.Printf("NewBulkUpdateRequest Items is :%+v\n", item)
			fmt.Printf("NewBulkUpdateRequest Items err is :%+v\n", item.Error)
		}
	}*/
	fmt.Println("=======================  NewBulkUpdateRequest  es  result =======================")

}

func RenderHTML(data model.EsApproval) string {

	var tmpl string
	tmpl = retTmpl(data)

	if tmpl == "" {
		return ""
	}

	funcMap := template.FuncMap{
		"contains":                   strings.Contains,
		"parseCustomizeInfoPosition": parseCustomizeInfoPosition,
		"mul":                        mul,
		"parseFloat":                 parseFloat,
		"toFloat64":                  toFloat64,
		"add":                        add,
		"parseJSON":                  parseJSON,
	}

	// 解析模板
	t, err := template.New("approval").Funcs(funcMap).Parse(tmpl)
	if err != nil {
		fmt.Println("=======================  renderHTML ========================= ")
		fmt.Printf("Error parsing template: %s\n", err)
		zap.L().Error("Error parsing template", zap.Error(err))
		fmt.Println("=======================  renderHTML ========================= ")
		return ""
	}
	var result strings.Builder
	err = t.Execute(&result, data)
	if err != nil {
		fmt.Println("=======================  renderHTML Execute ========================= ")
		fmt.Printf("Error Execute template: %s\n", err)
		zap.L().Error("Error Execute template", zap.Error(err))
		fmt.Println("=======================  renderHTML Execute ========================= ")
		return ""
	}
	return result.String()
}

func retTmpl(data model.EsApproval) string {
	// 根据 审批类型 分类
	switch {
	case data.Type == "work":
		return html.Work
	case data.Type == "exhibition":
		return html.Exhibition
	case data.Type == "bundle":
		return html.Bundle
	case data.Type == "show":
		return html.Show
	case data.Type == "bundlePayPrice":
		return html.BundlePayPrice
	case data.Type == "artExhibitionReward":
		return html.Exhibition
	case data.Type == "showUpdate":
		return html.ShowUpdate
	case data.Type == "promotion":
		return html.Promotion
	case data.Type == "staffSupply":
		return html.StaffSupply
	case data.Type == "checkIn":
		return html.CheckIn
	case data.Type == "makeUp":
		return html.MakeUp
	case data.Type == "outWork":
		return html.OutWork
	case data.Type == "banShow":
		return ""
	case data.Type == "goOut":
		return html.GoOut
	case data.Type == "businessTrip":
		return html.BusinessTrip
	case data.Type == "overTime":
		return html.OverTime
	case data.Type == "financialFormApply":
		return html.FinancialFormApply
	case isLeave(data):
		return html.Leave
	case isLeaveApply(data):
		return html.LeaveApply
	case isCustom(data):
		return html.Custom
	case isEmploy(data):
		return html.Employ
	case isTurnover(data):
		return html.Turnover
	case isHandover(data):
		return html.Handover
	}
	return ""
}

func isCustom(data model.EsApproval) bool {
	if data.IsCustom == 1 {
		return true
	}
	return false
}

func isLeave(data model.EsApproval) bool {
	if data.Type == "annualLeave" {
		return true
	} else if data.Type == "dayOff" {
		return true
	} else if data.Type == "leave" {
		return true
	} else if data.Type == "sick" {
		return true
	} else if data.Type == "leave" {
		return true
	} else if data.Type == "funeralLeave" {
		return true
	} else if data.Type == "maritalLeave" {
		return true
	} else if data.Type == "maternityLeave" {
		return true
	} else if data.Type == "paternityLeave" {
		return true
	} else if data.Type == "parentalLeave" {
		return true
	} else if data.Type == "nursingLeave" {
		return true
	} else if data.Type == "matingCheckLeave" {
		return true
	} else if data.Type == "breastFeedingLeave" {
		return true
	} else if data.Type == "abortLeave" {
		return true
	}
	return false
}

func isLeaveApply(data model.EsApproval) bool {
	if data.Type == "maternityLeaveApply" {
		return true
	} else if data.Type == "annualLeaveApply" {
		return true
	} else if data.Type == "maritalLeaveApply" {
		return true
	} else if data.Type == "matingCheckLeaveApply" {
		return true
	} else if data.Type == "paternityLeaveApply" {
		return true
	} else if data.Type == "nursingLeaveApply" {
		return true
	} else if data.Type == "parentalLeaveApply" {
		return true
	} else if data.Type == "funeralLeaveApply" {
		return true
	}
	return false
}

func isEmploy(data model.EsApproval) bool {
	if strings.Contains(data.Type, "employ") {
		return true
	}
	return false
}

func isTurnover(data model.EsApproval) bool {
	if strings.Contains(data.Type, "turnover") {
		return true
	}
	return false
}

func isHandover(data model.EsApproval) bool {
	if strings.Contains(data.Type, "handover") {
		return true
	}
	return false
}

type ApprovalValue struct {
	PositionName   string
	DepartmentID   int64
	DepartmentName string
}

func parseCustomizeInfoPosition(approvalValue string) (*ApprovalValue, error) {
	position := &ApprovalValue{}
	if err := json.Unmarshal([]byte(approvalValue), &position); err != nil {
		return nil, err
	}
	return position, nil
}

func mul(a, b float64) float64 {
	return a * b
}

func parseFloat(s string) (float64, error) {
	if s == "" {
		return 0, nil
	}
	return strconv.ParseFloat(s, 64)
}

func toFloat64(u uint64) float64 {
	if u == 0 {
		return 0
	}
	return float64(u)
}

func add(a, b int) int {
	return a + b
}

func parseJSON(s string) ([]string, error) {
	var result []string
	err := json.Unmarshal([]byte(s), &result)
	return result, err
}