package service

import (
	"fmt"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_manufacture"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/util/converter"
	"strings"

	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/excel"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/excelData/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/excelData/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/domainService"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_user"
)

type ExcelDataService struct {
}

func NewExcelDataService(param map[string]interface{}) *ExcelDataService {
	return &ExcelDataService{}
}

// ImportCooperationUser 导入共创用户信息
func (srv ExcelDataService) ImportCooperationUser(importDataCommand *command.ImportDataCommand) (interface{}, error) {
	initPassword, _, err := domainService.GetInitPassword(importDataCommand.Operator)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	userGateway := allied_creation_user.NewHttplibAlliedCreationUser(importDataCommand.Operator)
	orgResult, err := userGateway.OrgGet(allied_creation_user.ReqOrgGet{
		OrgId: int(importDataCommand.Operator.OrgId),
	})
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	excelImport := excel.NewExcelImport()
	excelImport.RowBegin = 3 //第二行开始读取
	excelImport.DataFields = []excel.DataField{
		{EnName: "userCode", CnName: "*用户编码"},
		{EnName: "userName", CnName: "*用户姓名"},
		{EnName: "cooperationCompany", CnName: "合伙公司"},
		{EnName: "cooperationDeadline", CnName: "合伙到期"},
		{EnName: "enableStatus", CnName: "*用户状态"},
		{EnName: "phone", CnName: "*手机号"},
		{EnName: "email", CnName: "邮箱"},
	}
	excelData, err := converter.OpenImportFileFromIoReader(excelImport, importDataCommand.Reader, importDataCommand.FileExt) //excelImport.OpenExcelFromIoReader(importDataCommand.Reader)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	users := make([]allied_creation_user.BatchAddUserItem, 0)
	for _, v := range excelData {
		item := allied_creation_user.BatchAddUserItem{
			CompanyId:           importDataCommand.Operator.CompanyId,
			UserType:            domain.UserTypeCooperation,
			UserCode:            v["userCode"],
			Org:                 orgResult.OrgCode,
			UserName:            strings.TrimSpace(v["userName"]),
			Phone:               strings.TrimSpace(v["phone"]),
			Email:               strings.TrimSpace(v["email"]),
			EnableStatus:        strings.TrimSpace(v["enableStatus"]),
			CooperationCompany:  v["cooperationCompany"],
			CooperationDeadline: v["cooperationDeadline"],
		}
		users = append(users, item)
	}

	result, err := userGateway.UserBatchAdd(allied_creation_user.ReqBatchAddUser{
		Users:    users,
		Password: initPassword,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return srv.importResultWithHeader(excelImport.DataFields, result.FailRows, len(users)), nil
}

// ImportCompanyUser 导入公司用户信息
func (srv ExcelDataService) ImportCompanyUser(importDataCommand *command.ImportDataCommand) (interface{}, error) {
	initPassword, _, err := domainService.GetInitPassword(importDataCommand.Operator)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	excelImport := excel.NewExcelImport()
	excelImport.RowBegin = 3 //第二行开始读取
	excelImport.DataFields = []excel.DataField{
		{EnName: "userCode", CnName: "*用户编码"},
		{EnName: "userName", CnName: "*用户姓名"},
		{EnName: "org", CnName: "*组织机构"},
		{EnName: "department", CnName: "*所属部门"},
		{EnName: "enableStatus", CnName: "*用户状态"},
		{EnName: "phone", CnName: "*手机号"},
		{EnName: "employeeType", CnName: "*员工类型"},
		{EnName: "icCardNumber", CnName: "IC卡号"},
		{EnName: "email", CnName: "邮箱"},
	}
	excelData, err := excelImport.OpenExcelFromIoReader(importDataCommand.Reader)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	users := make([]allied_creation_user.BatchAddUserItem, 0)
	for _, v := range excelData {
		if srv.fieldValueAllEmpty(v) {
			continue
		}
		item := allied_creation_user.BatchAddUserItem{
			CompanyId:    importDataCommand.Operator.CompanyId,
			UserType:     domain.UserTypeEmployee,
			UserCode:     strings.TrimSpace(v["userCode"]),
			Org:          strings.TrimSpace(v["org"]),
			Department:   strings.TrimSpace(v["department"]),
			UserName:     strings.TrimSpace(v["userName"]),
			Phone:        strings.TrimSpace(v["phone"]),
			Email:        strings.TrimSpace(v["email"]),
			EnableStatus: strings.TrimSpace(v["enableStatus"]),
			EmployeeType: strings.TrimSpace(v["employeeType"]),
			IcCardNumber: strings.TrimSpace(v["icCardNumber"]),
		}
		users = append(users, item)
	}
	userGateway := allied_creation_user.NewHttplibAlliedCreationUser(importDataCommand.Operator)
	result, err := userGateway.UserBatchAdd(allied_creation_user.ReqBatchAddUser{
		Users:    users,
		Password: initPassword,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return srv.importResultWithHeader(excelImport.DataFields, result.FailRows, len(users)), nil
}

// ImportOrganization 导入组织
func (srv ExcelDataService) ImportOrganization(importDataCommand *command.ImportDataCommand) (interface{}, error) {
	excelImport := excel.NewExcelImport()
	excelImport.RowBegin = 3 //第二行开始读取
	excelImport.DataFields = []excel.DataField{
		{EnName: "orgCode", CnName: "*部门编码"},
		{EnName: "orgName", CnName: "*部门名称"},
		{EnName: "parentOrgCode", CnName: "*上级部门编码"},
	}
	excelData, err := excelImport.OpenExcelFromIoReader(importDataCommand.Reader)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	items := make([]allied_creation_user.BatchAddOrgItem, 0)
	for _, v := range excelData {
		if srv.fieldValueAllEmpty(v) {
			continue
		}
		item := allied_creation_user.BatchAddOrgItem{
			CompanyId:     importDataCommand.Operator.CompanyId,
			OrgCode:       v["orgCode"],
			OrgName:       v["orgName"],
			ParentOrgCode: v["parentOrgCode"],
		}
		items = append(items, item)
	}
	userGateway := allied_creation_user.NewHttplibAlliedCreationUser(importDataCommand.Operator)
	result, err := userGateway.OrgBatchAdd(allied_creation_user.ReqBatchAddOrg{
		OrgList: items,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return srv.importResultWithHeader(excelImport.DataFields, result.FailRows, len(items)), nil
}

// ImportProduct 导入生产信息
func (srv ExcelDataService) ImportProduct(importDataCommand *command.ImportDataCommand) (interface{}, error) {
	excelImport := excel.NewExcelImport()
	excelImport.RowBegin = 3 //第二行开始读取
	excelImport.DataFields = []excel.DataField{
		{EnName: "productCode", CnName: "产品编号"},
		{EnName: "productName", CnName: "*品名"},
		{EnName: "unit", CnName: "*规格"},
		{EnName: "productCategory", CnName: "*类别"},
		{EnName: "unitWeight", CnName: "投入单份重量"},
	}
	excelData, err := converter.OpenImportFileFromIoReader(excelImport, importDataCommand.Reader, importDataCommand.FileExt) //excelImport.OpenExcelFromIoReader(importDataCommand.Reader)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	items := make([]*domain.ImportProductItem, 0)
	for _, v := range excelData {
		item := &domain.ImportProductItem{
			ProductCode:     strings.TrimSpace(v["productCode"]),
			ProductName:     strings.TrimSpace(v["productName"]),
			ProductCategory: strings.TrimSpace(v["productCategory"]),
			Unit:            strings.TrimSpace(v["unit"]),
			UnitWeight:      strings.TrimSpace(v["unitWeight"]),
		}
		items = append(items, item)
	}

	svr := allied_creation_manufacture.NewHttpLibAlliedCreationManufacture(importDataCommand.Operator)
	result, err := svr.BatchAddProduct(allied_creation_manufacture.BatchAddProductRequest{
		List: items,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return srv.importResultWithHeader(excelImport.DataFields, *result, len(items)), nil
}

// ImportProduct 导入生产信息
func (srv ExcelDataService) ImportDevice(importDataCommand *command.ImportDataCommand) (interface{}, error) {
	excelImport := excel.NewExcelImport()
	excelImport.RowBegin = 3 //第二行开始读取
	excelImport.DataFields = []excel.DataField{
		{EnName: "deviceCode", CnName: "*设备编号"},
		{EnName: "deviceName", CnName: "*设备名称"},
		{EnName: "deviceModel", CnName: "*设备型号"},
		{EnName: "deviceType", CnName: "*设备类型"},
		{EnName: "brand", CnName: "品牌"},
		{EnName: "status", CnName: "*状态"},
		{EnName: "level", CnName: "*风险等级"},
	}
	excelData, err := converter.OpenImportFileFromIoReader(excelImport, importDataCommand.Reader, importDataCommand.FileExt) //excelImport.OpenExcelFromIoReader(importDataCommand.Reader)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	items := make([]*domain.ImportDeviceItem, 0)
	for _, v := range excelData {
		item := &domain.ImportDeviceItem{
			DeviceCode:  strings.TrimSpace(v["deviceCode"]),
			DeviceName:  strings.TrimSpace(v["deviceName"]),
			DeviceModel: strings.TrimSpace(v["deviceModel"]),
			DeviceType:  strings.TrimSpace(v["deviceType"]),
			Brand:       strings.TrimSpace(v["brand"]),
			Status:      strings.TrimSpace(v["status"]),
			Level:       strings.TrimSpace(v["level"]),
		}
		items = append(items, item)
	}

	svr := allied_creation_manufacture.NewHttpLibAlliedCreationManufacture(importDataCommand.Operator)
	result, err := svr.BatchAddDevice(allied_creation_manufacture.BatchAddDeviceRequest{
		List: items,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	return srv.importResultWithHeader(excelImport.DataFields, *result, len(items)), nil
}

// 导入结果
func (srv ExcelDataService) importResultWithHeader(headers []excel.DataField, failRows []interface{}, totalRow int) interface{} {
	var result = map[string]interface{}{
		"successCount": 0,
		"fail":         struct{}{},
	}
	if len(failRows) == 0 {
		result["successCount"] = totalRow
	}
	if len(failRows) > 0 {
		fail := map[string]interface{}{
			"body": failRows,
		}
		var header = make(map[string]string)
		for i := 0; i < len(headers); i++ {
			item := headers[i]
			header[item.EnName] = item.CnName
		}
		fail["header"] = header
		result["fail"] = fail
	}
	return result
}

func (srv ExcelDataService) fieldValueAllEmpty(param map[string]string) bool {
	isAllEmpty := true
	for _, v := range param {
		value := strings.TrimSpace(v)
		if len(value) > 0 {
			isAllEmpty = false
		}
	}
	return isAllEmpty
}

// FileImportTemplate 导入模板
func (srv ExcelDataService) FileImportTemplate(importDataCommand *command.ImportDataCommand) (interface{}, error) {
	var mapTemplate = map[string]string{
		domain.ImportCompanyUser:           "https://timeless-world.oss-cn-shenzhen.aliyuncs.com/open-api/dev_online/20210916/object/1631807485_EaxECeRz23WpzrMZmbwdEPRJ3Pdxpx5X.xlsx",
		domain.ImportOrganization:          "https://timeless-world.oss-cn-shenzhen.aliyuncs.com/open-api/dev_online/20210916/object/1631807490_r2XWhGmbWWmpbeePBkZ3EJQFKcZEMpEm.xlsx",
		domain.ImportDividendsOrders:       "https://timeless-world.oss-cn-shenzhen.aliyuncs.com/open-api/dev_online/20210927/object/1632743206_NPYTKw6RGhXn4TpYNEQhGGdCkXKXTnxM.xlsx",
		domain.ImportCooperationUser:       "https://timeless-world.oss-cn-shenzhen.aliyuncs.com/open-api/dev_online/20210926/object/1632635345_SbfzmkXjQHhCwPw4MB7zb5EBBtdp2MSE.xlsx",
		domain.ImportDividendsReturnOrders: "https://timeless-world.oss-cn-shenzhen.aliyuncs.com/open-api/dev_online/20210927/object/1632743214_rNHm6ZBXZaC5xKTrsE7M4h45MY6n6Ff3.xlsx",
		domain.ImportProducts:              "https://timeless-world.oss-cn-shenzhen.aliyuncs.com/open-api/dev_online/20220120/object/1642670543_cbraNKjNPHcbN6RNBYQBrwhC7BXGbDWp.xlsx",
		domain.ImportDevices:               "https://timeless-world.oss-cn-shenzhen.aliyuncs.com/open-api/dev_online/20220126/object/1643184320_hT6sY5BKHmBa4TynfSGSCGyZ2KTTtzkj.xlsx",
	}
	var url string
	var ok bool
	if url, ok = mapTemplate[importDataCommand.Code]; !ok {
		return nil, application.ThrowError(application.BUSINESS_ERROR, fmt.Sprintf("模板:%v 不存在", importDataCommand.Code))
	}
	return map[string]string{
		"url": url,
	}, nil
}

func (srv ExcelDataService) GetExcelDataFields(param *query.ExcelDataFieldsQuery) (interface{}, error) {
	dataFileds := []DataFieldOptions{}
	switch param.Code {
	case domain.ExportCompanyUser:
		dataFileds = (ExportCompanyUserData{}).AllFields()
	case domain.ExportCooperationUser:
		dataFileds = (ExportCooperationUserData{}).AllFields()
	}
	return dataFileds, nil
}