package web_client

import (
	"fmt"
	"io"
	"strings"

	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/port/beego/controllers"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/port/beego/middleware"

	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"

	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/excelData/command"

	"github.com/beego/beego/v2/server/web/context"
	"github.com/linmadan/egglib-go/utils/excel"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/excelData/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/excelData/service"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_cooperation"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_manufacture"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"
)

type ExcelDataController struct {
	baseController
}

func (controller *ExcelDataController) responseExcelByFile(ctx *context.Context, excelExport *excel.ExcelExport, fileName string) error {
	ctx.Output.Header("Content-Disposition", "attachment; filename="+fileName)
	ctx.Output.Header("Content-Description", "File Transfer")
	ctx.Output.Header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
	ctx.Output.Header("Content-Transfer-Encoding", "binary")
	ctx.Output.Header("Expires", "0")
	ctx.Output.Header("Cache-Control", "must-revalidate")
	ctx.Output.Header("Pragma", "public")
	//跳过保存文件，直接写入ctx.ResponseWriter
	excelExport.ExcelFile.Write(ctx.ResponseWriter)
	return nil
}

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

// ImportDividendsOrder 导入分红订单
func (controller *ExcelDataController) ImportDividendsOrder() {
	importDividendsOrder(controller)
}

func importDividendsOrder(controller *ExcelDataController) {

	fileReader, err := controller.GetExcelFile()
	if err != nil {
		controller.Response(nil, err)
		return
	}
	excelImport := excel.NewExcelImport()
	excelImport.RowBegin = 3 //第3行开始读取
	excelImport.DataFields = []excel.DataField{
		{EnName: "OriginalOrderNum", CnName: "*来源单号"},
		{EnName: "DividendsCustomerName", CnName: "*客户名称"},
		{EnName: "OrderGoodName", CnName: "*产品名称"},
		{EnName: "OrderTime", CnName: "*订单日期"},
		{EnName: "RegionName", CnName: "*订单区域"},
		{EnName: "OrderGoodQuantity", CnName: "*产品数量"},
		{EnName: "OrderGoodPrice", CnName: "*产品价格"},
		{EnName: "Expense", CnName: "费用"},
		{EnName: "CooperationContractNumber", CnName: "*项目合约编号"},
	}
	excelData, err := excelImport.OpenExcelFromIoReader(fileReader)
	if err != nil {
		log.Logger.Error("解析excel文件失败，" + err.Error())
		controller.Response(nil, err)
		return
	}
	//订单数据
	var returnedOrderData []allied_creation_cooperation.ImportDividendsOrderData
	for _, v := range excelData {
		if allEmpty := controller.fieldValueAllEmpty(v); allEmpty {
			//以全字段空跳过
			break
		}
		//TODO 按需转化
		item := allied_creation_cooperation.ImportDividendsOrderData{
			OriginalOrderNum:          strings.TrimSpace(v["OriginalOrderNum"]),
			DividendsCustomerName:     strings.TrimSpace(v["DividendsCustomerName"]),
			OrderGoodName:             strings.TrimSpace(v["OrderGoodName"]),
			OrderTime:                 strings.TrimSpace(v["OrderTime"]),
			RegionName:                strings.TrimSpace(v["RegionName"]),
			OrderGoodQuantity:         strings.TrimSpace(v["OrderGoodQuantity"]),
			OrderGoodPrice:            strings.TrimSpace(v["OrderGoodPrice"]),
			Expense:                   strings.TrimSpace(v["Expense"]),
			CooperationContractNumber: strings.TrimSpace(v["CooperationContractNumber"]),
		}
		returnedOrderData = append(returnedOrderData, item)
	}
	creationCooperationGate := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(controller.GetOperator())
	result, err := creationCooperationGate.ImportDividendsOrder(allied_creation_cooperation.ReqImportDividendsOrder{
		DividendsOrderData: returnedOrderData,
	})
	if err != nil {
		controller.Response(nil, err)
		return
	}
	controller.Response(result, nil)
}

// ImportDividendsReturnedOrder 导入分红退货单
func (controller *ExcelDataController) ImportDividendsReturnedOrder() {
	importDividendsReturnedOrder(controller)
}

func importDividendsReturnedOrder(controller *ExcelDataController) {

	fileReader, err := controller.GetExcelFile()
	if err != nil {
		controller.Response(nil, err)
		return
	}
	excelImport := excel.NewExcelImport()
	excelImport.RowBegin = 3 //第2行表头开始读取
	excelImport.DataFields = []excel.DataField{
		{EnName: "OriginalOrderNum", CnName: "*来源单号"},
		{EnName: "DividendsReturnedCustomerName", CnName: "*客户名称"},
		{EnName: "OrderGoodName", CnName: "*产品名称"},
		{EnName: "DividendsReturnedDate", CnName: "*退货日期"},
		{EnName: "OrderTime", CnName: "*订单日期"},
		{EnName: "RegionName", CnName: "*退货区域"},
		{EnName: "OrderGoodQuantity", CnName: "*退货数量"},
		{EnName: "OrderGoodPrice", CnName: "*退货价格"},
		{EnName: "CooperationContractNumber", CnName: "*项目合约编号"},
	}
	excelData, err := excelImport.OpenExcelFromIoReader(fileReader)
	if err != nil {
		log.Logger.Error("解析excel文件失败，" + err.Error())
		controller.Response(nil, err)
		return
	}
	//退货单数据
	returnedOrderData := []allied_creation_cooperation.ImportDividendsReturnedOrderData{}
	for _, v := range excelData {
		if allEmpty := controller.fieldValueAllEmpty(v); allEmpty {
			//以全字段空跳过
			break
		}
		//TODO 按需转化
		item := allied_creation_cooperation.ImportDividendsReturnedOrderData{
			OriginalOrderNum:              strings.TrimSpace(v["OriginalOrderNum"]),
			DividendsReturnedCustomerName: strings.TrimSpace(v["DividendsReturnedCustomerName"]),
			OrderGoodName:                 strings.TrimSpace(v["OrderGoodName"]),
			DividendsReturnedDate:         strings.TrimSpace(v["DividendsReturnedDate"]),
			OrderTime:                     strings.TrimSpace(v["OrderTime"]),
			RegionName:                    strings.TrimSpace(v["RegionName"]),
			OrderGoodQuantity:             strings.TrimSpace(v["OrderGoodQuantity"]),
			OrderGoodPrice:                strings.TrimSpace(v["OrderGoodPrice"]),
			CooperationContractNumber:     strings.TrimSpace(v["CooperationContractNumber"]),
		}
		returnedOrderData = append(returnedOrderData, item)
	}
	creationCooperationGate := allied_creation_cooperation.NewHttplibAlliedCreationCooperation(controller.GetOperator())
	result, err := creationCooperationGate.ImportDividendsReturnedOrder(allied_creation_cooperation.ReqImportDividendsReturnedOrder{
		DividendsReturnedOrderData: returnedOrderData,
	})
	if err != nil {
		controller.Response(nil, err)
		return
	}
	controller.Response(result, nil)
}

// FileImport 文件导入
func (controller *ExcelDataController) FileImport() {
	code := controller.GetString("code")
	switch code {
	case domain.ImportDividendsOrders:
		importDividendsOrder(controller)
	case domain.ImportDividendsReturnOrders:
		importDividendsReturnedOrder(controller)
	case "ImportProductRecordLevel2":
		//车间制造-二级品审核导入
		fn := middleware.RedirectInternalService("/v1/web", allied_creation_manufacture.NewHttpLibAlliedCreationManufacture(domain.Operator{}))
		fn(controller.Ctx)
	case "ImportAttendance":
		// 车间制造-工时管理导入
		fn := middleware.RedirectInternalService("/v1/web", allied_creation_manufacture.NewHttpLibAlliedCreationManufacture(domain.Operator{}))
		fn(controller.Ctx)
	case "ImportProductTrouble":
		//车间制造-事故管理导入
		fn := middleware.RedirectInternalService("/v1/web", allied_creation_manufacture.NewHttpLibAlliedCreationManufacture(domain.Operator{}))
		fn(controller.Ctx)
	default:
		defaultImport(controller)
	}
}

func defaultImport(controller *ExcelDataController) {
	var (
		data     interface{}
		err      error
		r        io.Reader
		ext      string
		fileName string
	)
	excelService := service.NewExcelDataService(nil)
	r, ext, fileName, err = controller.GetFileWithExt()
	if err != nil {
		controller.Response(nil, err)
		return
	}
	cmd := &command.ImportDataCommand{}
	controller.ParseForm(cmd)
	cmd.Operator = controller.GetOperator()
	cmd.Reader = r
	cmd.FileExt = ext
	cmd.FileName = fileName
	switch cmd.Code {
	case domain.ImportCompanyUser:
		data, err = excelService.ImportCompanyUser(cmd)
	case domain.ImportCooperationUser:
		data, err = excelService.ImportCooperationUser(cmd)
	case domain.ImportOrganization:
		data, err = excelService.ImportOrganization(cmd)
	case domain.ImportProducts:
		data, err = excelService.ImportProduct(cmd)
	case domain.ImportDevices:
		data, err = excelService.ImportDevice(cmd)
	case domain.ImportCosts:
		data, err = excelService.ImportCost(cmd)
	default:
		err = fmt.Errorf("导入不存在 Code:%v", cmd.Code)
	}
	controller.Response(data, err)
}

func (controller *ExcelDataController) FileImportTemplate() {
	excelService := service.NewExcelDataService(nil)
	cmd := &command.ImportDataCommand{}
	code := controller.GetString(":code")
	cmd.Code = code
	var data interface{}
	data, err := excelService.FileImportTemplate(cmd)
	controller.Response(data, err)
}

// FileExport 文件导出
func (controller *ExcelDataController) FileExport() {
	fileExport(controller, "")
}

func fileExport(controller *ExcelDataController, code string) {
	// 1.读取command
	exportDataCommand := &command.ExportDataCommand{}
	err := controller.Unmarshal(exportDataCommand)
	if err != nil {
		log.Logger.Debug("json err:" + err.Error())
		controller.Response(nil, err)
		return
	}
	exportDataCommand.Operator = controller.GetOperator()

	if exportDataCommand.Code == "" && code != "" {
		exportDataCommand.Code = code
	}
	// 2.读取data
	var data excel.ExcelMaker
	var filename string
	var excelService = service.NewExcelDataService(nil)
	switch exportDataCommand.Code {
	case domain.ExportCompanyUser:
		companyUserListQuery := &query.CompanyUserListQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportCompanyUser(companyUserListQuery)
		filename = "导出公司用户"
	case domain.ExportCooperationUser:
		companyUserListQuery := &query.CooperationUserListQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportCooperationUser(companyUserListQuery)
		filename = "导出共创用户"
	case domain.ExportProducts:
		companyUserListQuery := &query.SearchProductQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportProducts(companyUserListQuery)
		filename = "导出商品"
	case domain.ExportManufactureEmployeeProductive:
		companyUserListQuery := &query.ManufactureEmployeeProductiveQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportEmployeeProductive(companyUserListQuery)
		filename = "导出员工产能统计"
	case domain.ExportManufactureWorkshopProductive:
		companyUserListQuery := &query.ManufactureWorkshopProductiveQuery{}
		exportDataCommand.UnmarshalQuery(companyUserListQuery)
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportWorkshopProductive(companyUserListQuery)
		filename = "导出车间产能汇总"
	case domain.ExportManufactureEmployeeAttendanceStatics:
		companyUserListQuery := &query.ManufactureExportEmployeeAttendanceStaticsQuery{}
		controllers.Must(exportDataCommand.UnmarshalQuery(companyUserListQuery))
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportEmployeeAttendanceStatics(companyUserListQuery)
		filename = "导出员工工时统计"
	case domain.ExportManufactureWorkshopAttendanceStatics:
		companyUserListQuery := &query.ManufactureExportWorkshopAttendanceStaticsQuery{}
		controllers.Must(exportDataCommand.UnmarshalQuery(companyUserListQuery))
		companyUserListQuery.Operator = exportDataCommand.Operator
		data, err = excelService.ExportWorkshopAttendanceStatics(companyUserListQuery)
		filename = "导出车间工时汇总"

	case domain.ExportCostStructuredDailyFillingAbnormalLog:
		query := &query.CostDailyFillingAbnormalLogQuery{}
		controllers.Must(exportDataCommand.UnmarshalQuery(query))
		query.Operator = exportDataCommand.Operator
		data, err = excelService.ExportDailyFillingAbnormalLog(query)
		filename = "异常记录"
	default:
		err = fmt.Errorf("export type :%v not exists", exportDataCommand.Code)
	}
	if err != nil {
		log.Logger.Debug("excelService.Export err:" + err.Error())
		controller.Response(nil, err)
		return
	}

	// 3.返回文件
	excelTool := excel.NewExcelExport()
	err = excelTool.ExportData(data, "")
	if err != nil {
		log.Logger.Debug("excelTool.ExportData err:" + err.Error())
		controller.Response(nil, err)
		return
	}
	controller.responseExcelByFile(controller.Ctx, excelTool, filename)
}

// ExportCompanyUser 导出公司用户
func (controller *ExcelDataController) ExportCompanyUser() {
	fileExport(controller, domain.ExportCompanyUser)
}

// ExportCooperationUser 导出共创用户
func (controller *ExcelDataController) ExportCooperationUser() {
	fileExport(controller, domain.ExportCooperationUser)
}

// ExportProducts 导出生产制造产品
func (controller *ExcelDataController) ExportProducts() {
	fileExport(controller, domain.ExportProducts)
}

// ExportManufactureEmployeeProductive 导出生产制造-员工产能统计
func (controller *ExcelDataController) ExportManufactureEmployeeProductive() {
	fileExport(controller, domain.ExportManufactureEmployeeProductive)
}

// ExportManufactureEmployeeProductive 导出生产制造-车间产能统计
func (controller *ExcelDataController) ExportManufactureWorkshopProductive() {
	fileExport(controller, domain.ExportManufactureWorkshopProductive)
}

// ExportManufactureEmployeeAttendanceStatics 导出生产制造-员工工时统计
func (controller *ExcelDataController) ExportManufactureEmployeeAttendanceStatics() {
	fileExport(controller, domain.ExportManufactureEmployeeAttendanceStatics)
}

// ExportManufactureWorkshopAttendanceStatics 导出生产制造-车间工时统计
func (controller *ExcelDataController) ExportManufactureWorkshopAttendanceStatics() {
	fileExport(controller, domain.ExportManufactureWorkshopAttendanceStatics)
}

func (controller *ExcelDataController) ExportCostStructuredDailyFillingAbnormalLog() {
	fileExport(controller, domain.ExportCostStructuredDailyFillingAbnormalLog)
}

// GetExcelDataFields 获取导出excel数据的可选字段
func (controller *ExcelDataController) GetExcelDataFields() {
	code := controller.GetString(":code")
	var excelService = service.NewExcelDataService(nil)
	data, _ := excelService.GetExcelDataFields(&query.ExcelDataFieldsQuery{Code: code})
	controller.Response(data, nil)
}