package controllers

import (
	"fmt"
	"io"
	"path/filepath"

	"github.com/beego/beego/v2/server/web/context"
	"github.com/linmadan/egglib-go/utils/excel"
	"github.com/linmadan/egglib-go/web/beego"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/ecelData/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/ecelData/service"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/log"
)

type ExcelDataController struct {
	beego.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
}

// FileImport 导入excel数据
func (controller *ExcelDataController) FileImport() {
	var (
		data interface{}
		err  error
		r    io.Reader
		ext  string
	)
	excelService := service.NewExcelDataService(nil)
	r, ext, err = controller.GetFileWithExt()
	if err != nil {
		controller.Response(nil, err)
		return
	}
	cmd := &command.ImportDataCommand{}
	controller.ParseForm(cmd)
	cmd.Operator = ParseOperateInfo(controller.BaseController)
	cmd.Reader = r
	cmd.FileExt = ext
	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 "ImportProductTrouble":
		data, err = excelService.ImportProductTrouble(cmd)
	case "ImportProductRecordLevel2":
		data, err = excelService.ImportProductRecord(cmd)
	case "ImportAttendance":
		data, err = excelService.ImportDataAttendance(cmd)
	default:
		err = fmt.Errorf("导入不存在 Code:%v", cmd.Code)
	}
	controller.Response(data, err)
}

// FileExport 文件导出
func (controller *ExcelDataController) FileExport() {
	// 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 = ParseOperateInfo(controller.BaseController)

	// 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 = "导出共创用户"
	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)
}

// GetExcelDataFields 获取导出excel数据的可选字段
func (controller *ExcelDataController) GetExcelDataFields() {

}

func (controller *ExcelDataController) GetFileWithExt() (io.Reader, string, error) {
	excelFile, fileHeader, err := controller.GetFile("file")
	if err != nil {
		log.Logger.Error(err.Error())
		return nil, "", fmt.Errorf("上传文件不存在")
	}
	ext := filepath.Ext(fileHeader.Filename)
	if !(ext == ".xlsx" || ext == ".xls" || ext == ".csv") {
		return nil, "", fmt.Errorf("仅支持上传文件格式 xls/xlsx/csv")
	}
	return excelFile, ext, nil
}

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