package commoditymanage

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	model "go-admin/app/admin/models"
	orm "go-admin/common/global"
	"go-admin/logger"
	"go-admin/tools/app"
	"golang.org/x/sync/errgroup"
	"io/ioutil"
	"net/http"
	"strconv"
	"strings"
	"time"
)

func ErpStockBatchImport(c *gin.Context) {
	//req := struct {
	//	File []byte `json:"file"`
	//}{}
	//if err := c.ShouldBindJSON(&req); err != nil {
	//	logger.Error(err)
	//	app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
	//	return
	//}
	model.EsStockLock.Lock()
	defer model.EsStockLock.Unlock()

	file, header, err := c.Request.FormFile("file")
	if err != nil {
		logger.Error("form file err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}

	readAll, err := ioutil.ReadAll(file)
	if err != nil {
		logger.Error("read all err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	fmt.Println("header:", header.Filename)
	//fmt.Println("readAll:", readAll)

	fileStart := time.Now().UnixMilli()
	bCol, _, err := model.FileExcelReaderImport(readAll, model.ErpStockFileExcelCols)
	if err != nil {
		logger.Error("file excel reader err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	fmt.Println("FileExcelReader", time.Now().UnixMilli()-fileStart)
	//fmt.Println("bCol", string(bCol))

	var stockFiles []model.ErpStockFileExcel
	err = json.Unmarshal(bCol, &stockFiles)
	if err != nil {
		logger.Error("erp commodity file excel unmarshal err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	if len(stockFiles) != 0 {
		stockFiles = stockFiles[1:]
	}
	stockier := model.NewStockImporter()
	fileStart = time.Now().UnixMilli()
	err = stockier.ErpStockFileExcelListProcessing(stockFiles)
	if err != nil {
		logger.Error("processing err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	fmt.Println("ErpStockFileExcelListProcessing", time.Now().UnixMilli()-fileStart)

	erpStocks := make([]model.ErpStockCommodity, 0, len(stockFiles))
	for i, _ := range stockFiles {
		erpStocks = append(erpStocks, stockFiles[i].ErpStockCommodity)
	}

	begin := orm.Eloquent.Begin()
	total := len(erpStocks)
	size := 200
	page := total / size
	if total%size != 0 {
		page += 1
	}
	errGroup := errgroup.Group{}
	for i := 0; i < page; i++ {
		if i == page-1 {
			stockList := erpStocks[i*size:]
			err = begin.Create(&stockList).Error
			if err != nil {
				begin.Rollback()
				logger.Error("create commodity  err:", err)
				app.Error(c, http.StatusInternalServerError, err, "导入失败")
				return
			}
		} else {
			errGroup.Go(func() error {
				stockList := erpStocks[i*size : (i+1)*size]
				err = begin.Create(&stockList).Error
				if err != nil {
					begin.Rollback()
					logger.Error("create commodity  err:", err)
					return err
				}
				return nil
			})
		}
	}
	err = stockier.ErpStockCountUpdate(begin)
	if err != nil {
		begin.Rollback()
		logger.Error("erp stock count update err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	err = stockier.ErpInventoryStockCreate(begin, stockFiles)
	if err != nil {
		begin.Rollback()
		logger.Error("erp inventory stock create err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	err = errGroup.Wait()
	if err != nil {
		begin.Rollback()
		logger.Error("err group wait err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}

	logging := model.Logging{
		Function:  "库存导入",
		Event:     model.LoggingEventInventoryImport,
		EventName: "库存导入",
	}
	logging.Create(c)

	//app.OK(c, erpStocks, "")
	app.OK(c, nil, "")
	//return
}

func ErpCommodityCreate(c *gin.Context) {
	req := struct {
		Name           string `json:"name" binding:"required"`
		ErpCategoryId  uint32 `json:"erp_category_id"  binding:"required"`
		IMEIType       uint32 `json:"imei_type" binding:"required"` // 1-无串码 2-串码
		ErpSupplierId  uint32 `json:"erp_supplier_id" binding:"required"`
		RetailPrice    uint32 `json:"retail_price" binding:"required"`
		MinRetailPrice uint32 `json:"min_retail_price" binding:"required"`
		StaffCostPrice uint32 `json:"staff_cost_price" binding:"required"`
		WholesalePrice uint32 `json:"wholesale_price" binding:"required"`
		Brokerage1     string `json:"brokerage_1" binding:"required"`
		Brokerage2     string `json:"brokerage_2"`
		MemberDiscount string `json:"member_discount"`
		Origin         string `json:"origin"`
		Remark         string `json:"remark" gorm:"type:varchar(512)"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	brokerage1Float, err := strconv.ParseFloat(req.Brokerage1, 64)
	if err != nil {
		logger.Error("brokerage1 err:", err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	brokerage2Float, err := strconv.ParseFloat(req.Brokerage2, 64)
	if err != nil {
		logger.Error("brokerage2 err:", err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	memberDiscountFloat, err := strconv.ParseFloat(req.MemberDiscount, 64)
	if err != nil {
		logger.Error("member discount err:", err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	commodity := &model.ErpCommodity{
		Number:          1,
		Name:            req.Name,
		ErpCategoryId:   req.ErpCategoryId,
		ErpCategoryName: "",
		IMEIType:        req.IMEIType,
		ErpSupplierId:   req.ErpSupplierId,
		ErpSupplierName: "",
		RetailPrice:     req.RetailPrice,
		MinRetailPrice:  req.MinRetailPrice,
		StaffCostPrice:  req.StaffCostPrice + req.WholesalePrice,
		WholesalePrice:  req.WholesalePrice,
		Brokerage1:      brokerage1Float,
		Brokerage2:      brokerage2Float,
		MemberDiscount:  memberDiscountFloat,
		Origin:          req.Origin,
		Remark:          req.Remark,
	}
	err = commodity.SetErpCategory()
	if err != nil {
		logger.Error("set erp category err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}
	commodity.IdInit()

	var catCommodity model.ErpCommodity
	err = orm.Eloquent.Table("erp_commodity").Where("erp_category_id=?", req.ErpCategoryId).
		Order("id DESC").Limit(1).Find(&catCommodity).Error
	if err != nil && err != model.RecordNotFound {
		logger.Error("cat erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}
	if catCommodity.Number != 0 {
		commodity.Number = catCommodity.Number + 1
	}
	commodity.SerialNumber = fmt.Sprintf("%06d%04d", commodity.ErpCategory.FullNum, commodity.Number)

	err = orm.Eloquent.Create(commodity).Error
	if err != nil {
		logger.Error("create commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}

	app.OK(c, commodity, "")
	return
}

func ErpCommodityList(c *gin.Context) {
	req := &model.ErpCommodityListReq{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	resp, err := req.List()
	if err != nil {
		logger.Error("erp commodity list err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, resp, "")
	return
}

func ErpCommodityDetail(c *gin.Context) {
	req := struct {
		ErpCommodityId uint32 `json:"erp_commodity_id"`
		SerialNumber   string `json:"serial_number"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	var commodity model.ErpCommodity
	qs := orm.Eloquent.Table("erp_commodity")
	if req.ErpCommodityId != 0 {
		qs = qs.Where("id=?", req.ErpCommodityId)
	}
	if req.SerialNumber != "" {
		qs = qs.Where("serial_number=?", req.SerialNumber)
	}
	err := qs.Find(&commodity).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, commodity, "")
	return
}

func ErpCommodityDel(c *gin.Context) {
	req := struct {
		ErpCommodityId uint32 `json:"erp_commodity_id" binding:"required"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	err := orm.Eloquent.Table("erp_commodity").Where("id=?", req.ErpCommodityId).Delete(&model.ErpCommodity{}).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, nil, "删除成功")
	return
}

func ErpCommodityEdit(c *gin.Context) {
	req := struct {
		Id             uint32 `json:"id" binding:"required"`
		Name           string `json:"name" binding:"required"`
		ErpCategoryId  uint32 `json:"erp_category_id"  binding:"required"`
		IMEIType       uint32 `json:"imei_type" binding:"required"` // 1-无串码 2-串码
		ErpSupplierId  uint32 `json:"erp_supplier_id" binding:"required"`
		RetailPrice    uint32 `json:"retail_price" binding:"required"`
		MinRetailPrice uint32 `json:"min_retail_price" binding:"required"`
		StaffCostPrice uint32 `json:"staff_cost_price" binding:"required"`
		WholesalePrice uint32 `json:"wholesale_price" binding:"required"`
		//Brokerage1     string `json:"brokerage_1" binding:"required"`
		//Brokerage2     string `json:"brokerage_2"`
		//MemberDiscount string `json:"member_discount"`
		Brokerage1     float64 `json:"brokerage_1" binding:"required"`
		Brokerage2     float64 `json:"brokerage_2"`
		MemberDiscount float64 `json:"member_discount"`
		Origin         string  `json:"origin"`
		Remark         string  `json:"remark" gorm:"type:varchar(512)"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	brokerage1Float := req.Brokerage1
	brokerage2Float := req.Brokerage2
	memberDiscountFloat := req.MemberDiscount
	//brokerage1Float, err := strconv.ParseFloat(req.Brokerage1, 64)
	//if err != nil {
	//	logger.Error("brokerage1 err:", err)
	//	app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
	//	return
	//}
	//brokerage2Float, err := strconv.ParseFloat(req.Brokerage2, 64)
	//if err != nil {
	//	logger.Error("brokerage2 err:", err)
	//	app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
	//	return
	//}
	//memberDiscountFloat, err := strconv.ParseFloat(req.MemberDiscount, 64)
	//if err != nil {
	//	logger.Error("member discount err:", err)
	//	app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
	//	return
	//}

	commodity := &model.ErpCommodity{
		Name:            req.Name,
		ErpCategoryId:   req.ErpCategoryId,
		ErpCategoryName: "",
		IMEIType:        req.IMEIType,
		ErpSupplierId:   req.ErpSupplierId,
		ErpSupplierName: "",
		RetailPrice:     req.RetailPrice,
		MinRetailPrice:  req.MinRetailPrice,
		StaffCostPrice:  req.StaffCostPrice + req.WholesalePrice,
		WholesalePrice:  req.WholesalePrice,
		Brokerage1:      brokerage1Float,
		Brokerage2:      brokerage2Float,
		MemberDiscount:  memberDiscountFloat,
		Origin:          req.Origin,
		Remark:          req.Remark,
	}
	commodity.ID = req.Id
	err := commodity.SetErpCategory()
	if err != nil {
		logger.Error("set erp category err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	commodity.IdInit()

	var catCommodity model.ErpCommodity
	//err = orm.Eloquent.Table("erp_commodity").Where("erp_category_id=?", req.Id).Limit(1).Find(&catCommodity).Error
	err = orm.Eloquent.Table("erp_commodity").Where("id=?", req.Id).Find(&catCommodity).Error
	if err != nil {
		logger.Error("cat erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	commodity.Number = catCommodity.Number
	commodity.SerialNumber = catCommodity.SerialNumber

	err = orm.Eloquent.Save(commodity).Error
	if err != nil {
		logger.Error("create commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}

	app.OK(c, commodity, "")
	return
}

func ErpCommodityBatchImport(c *gin.Context) {
	//req := struct {
	//	File []byte `json:"file"`
	//}{}
	//if err := c.ShouldBindJSON(&req); err != nil {
	//	logger.Error(err)
	//	app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
	//	return
	//}
	model.EsfLock.Lock()
	defer model.EsfLock.Unlock()
	file, header, err := c.Request.FormFile("file")
	if err != nil {
		logger.Error("form file err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}

	readAll, err := ioutil.ReadAll(file)
	if err != nil {
		logger.Error("read all err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	fmt.Println("header:", header.Filename)
	//fmt.Println("readAll:", readAll)
	// 导入商品自动添加分类
	bCol, _, err := model.FileExcelReader([]byte(readAll), model.ErpCommodityFileExcelCols)
	//bCol, err := model.FileExcelReader(req.File, model.ErpCommodityFileExcelCols, nil)
	if err != nil {
		logger.Error("file excel reader err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}

	fmt.Println("bCol", string(bCol))
	var commodityFiles []model.ErpCommodityFileExcel
	err = json.Unmarshal(bCol, &commodityFiles)
	if err != nil {
		logger.Error("erp commodity file excel unmarshal err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}
	if len(commodityFiles) != 0 {
		commodityFiles = commodityFiles[1:]
	}
	model.ErpCommodityFileExcelListProcessing(commodityFiles)
	commodities := make([]model.ErpCommodity, 0, len(commodityFiles))
	begin := orm.Eloquent.Begin()
	for i, _ := range commodityFiles {
		commodities = append(commodities, commodityFiles[i].ErpCommodity)
		err := begin.Create(&commodityFiles[i].ErpCommodity).Error
		if err != nil {
			begin.Rollback()
			logger.Error("create commodity files  err:", err)
			app.Error(c, http.StatusInternalServerError, err, "导入失败")
			return
		}
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		app.Error(c, http.StatusInternalServerError, err, "导入失败")
		return
	}

	app.OK(c, commodities, "")
	return
}

func BatchImportView(c *gin.Context) {
	//req := struct {
	//	File []byte `json:"file"`
	//}{}
	//if err := c.ShouldBindJSON(&req); err != nil {
	//	logger.Error(err)
	//	app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
	//	return
	//}

	file, header, err := c.Request.FormFile("file")
	if err != nil {
		logger.Error("form file err:", err)
		app.Error(c, http.StatusInternalServerError, err, "预览失败")
		return
	}

	readAll, err := ioutil.ReadAll(file)
	if err != nil {
		logger.Error("read all err:", err)
		app.Error(c, http.StatusInternalServerError, err, "预览失败")
		return
	}
	fmt.Println("header:", header.Filename)
	//fmt.Println("readAll:", readAll)
	//colsMap := make([]map[string]interface{}, 0)
	// 导入商品自动添加分类
	_, colsMap, err := model.FileExcelReader([]byte(readAll), nil)
	//_, err = model.FileExcelReader([]byte(readAll), model.ErpCommodityFileExcelCols, colsMap)
	//bCol, err := model.FileExcelReader(req.File, model.ErpCommodityFileExcelCols, nil)
	if err != nil {
		logger.Error("file excel reader err:", err)
		app.Error(c, http.StatusInternalServerError, err, "预览失败")
		return
	}
	fmt.Println("colsMap:", colsMap)
	if len(colsMap) != 0 {
		colsMap = colsMap[1:]
	}
	//cols, err := json.Marshal(&colsMap)
	//if err != nil {
	//	logger.Error("marshal err:", err)
	//	app.Error(c, http.StatusInternalServerError, err, "预览失败")
	//	return
	//}
	//fmt.Println("cols", string(cols))

	// 加锁
	//var commodityFiles []model.ErpCommodityFileExcel
	//err = json.Unmarshal(bCol, &commodityFiles)
	//if err != nil {
	//	logger.Error("erp commodity file excel unmarshal err:", err)
	//	app.Error(c, http.StatusInternalServerError, err, "导入失败")
	//	return
	//}
	//if len(commodityFiles) != 0 {
	//	commodityFiles = commodityFiles[1:]
	//}
	//model.ErpCommodityFileExcelListProcessing(commodityFiles)
	//commodities := make([]model.ErpCommodity, 0, len(commodityFiles))
	//begin := orm.Eloquent.Begin()
	//for i, _ := range commodityFiles {
	//	commodities = append(commodities, commodityFiles[i].ErpCommodity)
	//	err := begin.Create(&commodityFiles[i].ErpCommodity).Error
	//	if err != nil {
	//		begin.Rollback()
	//		logger.Error("create commodity files  err:", err)
	//		app.Error(c, http.StatusInternalServerError, err, "导入失败")
	//		return
	//	}
	//}
	//err = begin.Commit().Error
	//if err != nil {
	//	begin.Rollback()
	//	logger.Error("commit err:", err)
	//	app.Error(c, http.StatusInternalServerError, err, "导入失败")
	//	return
	//}

	app.OK(c, &colsMap, "")
	return
}

func ErpSupplierSave(c *gin.Context) {
	req := struct {
		Id             uint32 `json:"id"`
		Name           string `json:"name" binding:"required"`
		Contact        string `json:"contact" binding:"required"`
		Tel            string `json:"tel" binding:"required"`
		Address        string `json:"address" binding:"required"`
		OpeningBank    string `json:"opening_bank" binding:"required"`
		BankAccount    string `json:"bank_account" binding:"required"`
		PaymentCycle   uint32 `json:"payment_cycle" binding:"required"`
		TaxNumber      string `json:"tax_number"`
		StoreIds       string `json:"store_ids"`
		Landline       string `json:"landline"`
		Email          string `json:"email"`
		CompanyWebsite string `json:"company_website"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	supplier := &model.ErpSupplier{
		Name:           req.Name,
		Contact:        req.Contact,
		Tel:            req.Tel,
		Address:        req.Address,
		OpeningBank:    req.OpeningBank,
		BankAccount:    req.BankAccount,
		PaymentCycle:   req.PaymentCycle,
		TaxNumber:      req.TaxNumber,
		StoreIds:       req.StoreIds,
		Landline:       req.Landline,
		Email:          req.Email,
		CompanyWebsite: req.CompanyWebsite,
	}
	supplier.ID = req.Id

	err := orm.Eloquent.Save(supplier).Error
	if err != nil {
		logger.Error("create commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	if supplier.Number == "" {
		err = orm.Eloquent.Table("erp_supplier").Where("id=?", supplier.ID).
			Update("number", fmt.Sprintf("%03d", supplier.ID)).Error
		if err != nil {
			logger.Error("err:", err)
			app.Error(c, http.StatusInternalServerError, err, "操作失败")
			return
		}
	}

	var logging model.Logging
	if req.Id == 0 {
		logging = model.Logging{
			//Machine:     "",
			//StoreId:     0,
			//StoreName:   "",
			//OperatorUid: 0,
			//Operator:    "",
			Function:  "供应商资料",
			Event:     model.LoggingEventCreateSupplier,
			EventName: "新建供应商",
			//Ip:        "",
		}
	} else {
		logging = model.Logging{
			//Machine:     "",
			//StoreId:     0,
			//StoreName:   "",
			//OperatorUid: 0,
			//Operator:    "",
			Function:  "供应商资料",
			Event:     model.LoggingEventEditSupplier,
			EventName: "编辑供应商资料",
			//Ip:        "",
		}
	}
	logging.Create(c)

	app.OK(c, supplier, "")
	return
}

func ErpSupplierList(c *gin.Context) {
	req := &struct {
		Number   string `json:"number"`
		Name     string `json:"name"`
		PageNum  int    `json:"page_num"`
		PageSize int    `json:"page_size"`
		IsExport uint32 `json:"is_export"` // 1-导出
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	resp := &model.ErpSupplierListResp{
		PageNum:  req.PageNum,
		PageSize: req.PageSize,
	}
	page := req.PageNum - 1
	if page < 0 {
		page = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}

	qs := orm.Eloquent.Table("erp_supplier")
	if req.Number != "" {
		qs = qs.Where("number=?", req.Number)
	}
	if req.Name != "" {
		qs = qs.Where("name LIKE ?", req.Name)
	}
	var count int64
	err := qs.Count(&count).Error
	if err != nil {
		logger.Error("count err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}
	resp.Total = int(count)/req.PageSize + 1
	var suppliers []model.ErpSupplier
	if req.IsExport == 1 {
		err = qs.Order("id DESC").Find(&suppliers).Error
		if err != nil && err != model.RecordNotFound {
			logger.Error("dailys err:", err)
			app.Error(c, http.StatusInternalServerError, err, "导出失败")
			return
		}

		listExport, err := model.ErpSupplierListExport(suppliers)
		if err != nil {
			logger.Error("list export err:", err)
			app.Error(c, http.StatusInternalServerError, err, "导出失败")
			return
		}
		resp.ExportUrl = listExport
	} else {
		err = qs.Order("id DESC").Offset(page * req.PageSize).Limit(req.PageSize).Find(&suppliers).Error
		if err != nil && err != model.RecordNotFound {
			logger.Error("erp commodity list err:", err)
			app.Error(c, http.StatusInternalServerError, err, "获取失败")
			return
		}
		//rsp.List = list
		resp.List = suppliers
	}

	app.OK(c, resp, "")
	return
}

func ErpSupplierDetail(c *gin.Context) {
	req := struct {
		ErpSupplierId uint32 `json:"erp_supplier_id" binding:"required"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	var supplier model.ErpSupplier
	err := orm.Eloquent.Table("erp_supplier").Where("id=?", req.ErpSupplierId).Find(&supplier).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, supplier, "")
	return
}

func ErpSupplierDel(c *gin.Context) {
	req := struct {
		ErpSupplierId uint32 `json:"erp_supplier_id" binding:"required"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	err := orm.Eloquent.Table("erp_supplier").Where("id=?", req.ErpSupplierId).Delete(&model.ErpSupplier{}).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, nil, "")
	return
}

func ErpCategoryCreate(c *gin.Context) {
	req := struct {
		Name string `json:"name" binding:"required"`
		Pid  uint32 `json:"pid"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	category, err := model.ErpCategoryCreate(req.Name, req.Pid)
	if err != nil {
		logger.Error("category create err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}

	app.OK(c, category, "")
	return
}

func ErpCategoryList(c *gin.Context) {
	req := &model.ErpCategoryListReq{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	resp, err := req.List()
	if err != nil {
		logger.Error("erp commodity list err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, resp, "")
	return
}

func ErpCategoryDetail(c *gin.Context) {
	req := struct {
		ErpCategoryId uint32 `json:"erp_category_id" binding:"required"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	var category model.ErpCategory
	err := orm.Eloquent.Table("erp_category").Where("id=?", req.ErpCategoryId).Find(&category).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, category, "")
	return
}

func ErpCategoryDel(c *gin.Context) {
	req := struct {
		ErpCategoryId uint32 `json:"erp_category_id" binding:"required"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	err := orm.Eloquent.Where("id=?", req.ErpCategoryId).Delete(&model.ErpCategory{}).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "删除失败")
		return
	}

	app.OK(c, nil, "")
	return
}

func ErpCategoryEdit(c *gin.Context) {
	req := struct {
		Id    uint32 `json:"id" binding:"required"`
		Name  string `json:"name"`
		State uint32 `json:"state"`
		Pid   uint32 `json:"pid"`
		Level uint32 `json:"level"` // 分类层级
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	category, err := model.GetErpCategory(req.Id)
	if err != nil {
		logger.Error("get erp category err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}
	if req.Name != "" {
		var precede string
		if category.Level == 1 {
			precede = fmt.Sprintf("%03d", category.FullNum/1000)
		} else {
			precede = fmt.Sprintf("%03d-%03d", category.FullNum/1000, category.FullNum%1000)
		}

		if strings.HasPrefix(req.Name, precede) {
			category.Name = req.Name
		} else {
			category.Name = precede + req.Name
		}

	}
	if req.State != 0 {
		category.State = req.State
	}
	if req.Pid != 0 {
		category.Pid = req.Pid
	}
	if req.Level != 0 {
		category.Level = req.Level
		if category.Level == 1 {
			category.Pid = 0
		}
	}

	err = orm.Eloquent.Save(category).Error
	if err != nil {
		logger.Error("create commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}

	app.OK(c, category, "")
	return
}

func ErpCashierStoreCreate(c *gin.Context) {
	req := struct {
		Name        string   `json:"name" binding:"required"`
		BankName    string   `json:"bank_name"`
		BankAccount string   `json:"bank_account"`
		StoreNames  []uint32 `json:"store_name"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	exist, err := model.QueryRecordExist(fmt.Sprintf("SELECT * FROM erp_cashier WHERE `name`='%s'", req.Name))
	if err != nil {
		logger.Error("exist erp cashier err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}
	var cashier model.ErpCashier
	if !exist {
		//logger.Error("")
		//app.Error(c, http.StatusInternalServerError, err, "已存在")
		//return

		cashier = model.ErpCashier{
			Name:        req.Name,
			BankName:    req.BankName,
			BankAccount: req.BankAccount,
			State:       1,
			Remark:      "",
		}
		err = orm.Eloquent.Create(&cashier).Error
		if err != nil {
			logger.Error("cashier err:", err)
			app.Error(c, http.StatusInternalServerError, err, "创建失败")
			return
		}
	} else {
		err = orm.Eloquent.Table("erp_cashier").Where("name=?", req.Name).Find(&cashier).Error
		if err != nil {
			logger.Error("erp cashier err:", err)
			app.Error(c, http.StatusInternalServerError, err, "创建失败")
			return
		}
	}

	//cashier := &model.ErpCashier{
	//	Name:        req.Name,
	//	BankName:    req.BankName,
	//	BankAccount: req.BankAccount,
	//	State:       1,
	//	Remark:      "",
	//}
	//err = orm.Eloquent.Create(cashier).Error
	//if err != nil {
	//	logger.Error("cashier err:", err)
	//	app.Error(c, http.StatusInternalServerError, err, "创建失败")
	//	return
	//}

	if len(req.StoreNames) > 0 {
		var stores []model.Store
		err := orm.Eloquent.Table("store").Where("id IN (?)", req.StoreNames).Find(&stores).Error
		if err != nil {
			logger.Error("stores err:", err)
			app.Error(c, http.StatusInternalServerError, err, "创建失败")
			return
		}
		//fmt.Println("stores", stores)
		storeMap := make(map[uint32]string)
		for i, _ := range stores {
			storeMap[stores[i].ID] = stores[i].Name
		}
		begin := orm.Eloquent.Begin()
		for i, _ := range req.StoreNames {
			v, ok := storeMap[req.StoreNames[i]]

			storeCategory := &model.ErpStoreCashier{
				ErpCashierId: cashier.ID,
				Name:         req.Name,
				BankName:     req.BankName,
				BankAccount:  req.BankAccount,
				StoreId:      req.StoreNames[i],
				State:        1,
				Remark:       "",
			}
			if ok {
				storeCategory.StoreName = v
				//fmt.Println("StoreName", storeCategory.StoreName)
			}
			//fmt.Println("storeCategory", storeCategory)
			err := begin.Create(storeCategory).Error
			if err != nil {
				begin.Rollback()
				logger.Error("store category err:", err)
				app.Error(c, http.StatusInternalServerError, err, "创建失败")
				return
			}
		}
		err = begin.Commit().Error
		if err != nil {
			begin.Rollback()
			logger.Error("commit err:", err)
			app.Error(c, http.StatusInternalServerError, err, "创建失败")
			return
		}
	}

	app.OK(c, nil, "")
	return
}

func ErpCashierStoreBind(c *gin.Context) {
	req := struct {
		ErpCashierIds []uint32 `json:"erp_cashier_ids"`
		StoreId       uint32   `json:"store_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	cashierMap, err := model.GetErpCashierMap(req.ErpCashierIds)
	if err != nil {
		logger.Error("get erp cashier map err:", err)
		app.Error(c, http.StatusInternalServerError, err, "绑定失败")
		return
	}

	begin := orm.Eloquent.Begin()
	if len(req.ErpCashierIds) > 0 {
		for i, _ := range req.ErpCashierIds {
			v, ok := cashierMap[req.ErpCashierIds[i]]
			if ok && v != nil {
				storeCategory := &model.ErpStoreCashier{
					ErpCashierId: v.ID,
					Name:         v.Name,
					BankName:     v.BankName,
					BankAccount:  v.BankAccount,
					StoreId:      req.StoreId,
					State:        1,
					Remark:       "",
				}
				err := begin.Create(storeCategory).Error
				if err != nil {
					begin.Rollback()
					logger.Error("store category err:", err)
					app.Error(c, http.StatusInternalServerError, err, "绑定失败")
					return
				}
			}

		}
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		app.Error(c, http.StatusInternalServerError, err, "绑定失败")
		return
	}

	app.OK(c, nil, "")
	return
}

func ErpCashierStoreDel(c *gin.Context) {
	req := struct {
		ErpStoreCashierId uint32 `json:"erp_store_cashier_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	err := orm.Eloquent.Table("erp_store_cashier").Where("id=?", req.ErpStoreCashierId).Delete(&model.ErpStoreCashier{}).Error
	if err != nil {
		logger.Error("erp store cashier err:", err)
		app.Error(c, http.StatusInternalServerError, err, "操作失败")
		return
	}

	app.OK(c, nil, "")
	return
}

func ErpCashierStoreList(c *gin.Context) {
	req := struct {
		StoreId  uint32 `json:"store_id"`
		PageNum  int    `json:"page_num"`
		PageSize int    `json:"page_size"`
		IsExport uint32 `json:"is_export"` // 1-导出
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	//sysUser, err := model.GetSysUserByCtx(c)
	//if err != nil {
	//	logger.Error("sys user err:", err)
	//	app.Error(c, http.StatusUnauthorized, errors.New("para err"), "参数错误")
	//	return
	//}
	//req.StoreId = sysUser.StoreId

	resp := &model.ErpCashierStoreListResp{
		PageNum:  req.PageNum,
		PageSize: req.PageSize,
	}
	page := req.PageNum - 1
	if page < 0 {
		page = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}

	qs := orm.Eloquent.Table("erp_store_cashier")
	if req.StoreId != 0 {
		qs = qs.Where("store_id=?", req.StoreId)
	}
	var count int64
	err := qs.Count(&count).Error
	if err != nil {
		logger.Error("count err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}
	//total := int(count)/req.PageSize + 1
	resp.Total = int(count)/req.PageSize + 1
	var categories []model.ErpStoreCashier
	if req.IsExport == 1 {
		err = qs.Order("id DESC").Find(&categories).Error
		if err != nil && err != model.RecordNotFound {
			logger.Error("dailys err:", err)
			app.Error(c, http.StatusInternalServerError, err, "导出失败")
			return
		}

		listExport, err := model.ErpStoreCashierListExport(categories)
		if err != nil {
			logger.Error("list export err:", err)
			app.Error(c, http.StatusInternalServerError, err, "导出失败")
			return
		}
		resp.ExportUrl = listExport
	} else {
		err = qs.Order("id DESC").Offset(page * req.PageSize).Limit(req.PageSize).Find(&categories).Error
		if err != nil && err != model.RecordNotFound {
			logger.Error("erp commodity list err:", err)
			app.Error(c, http.StatusInternalServerError, err, "获取失败")
			return
		}
		resp.List = categories
	}

	//resp.List = categories
	//ret := map[string]interface{}{
	//	"total":     total,
	//	"page_num":  req.PageNum,
	//	"page_size": req.PageSize,
	//	"list":      categories,
	//}

	app.OK(c, resp, "")
	return
}

func ErpCashierList(c *gin.Context) {
	req := struct {
		Type     uint32 `json:"type"`
		PageNum  int    `json:"page_num"`
		PageSize int    `json:"page_size"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	resp := &model.ErpCashierListResp{
		PageNum:  req.PageNum,
		PageSize: req.PageSize,
	}
	page := req.PageNum - 1
	if page < 0 {
		page = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}

	qs := orm.Eloquent.Table("erp_cashier")
	if req.Type != 0 {
		qs = qs.Where("type=?", req.Type)
	}
	var count int64
	err := qs.Count(&count).Error
	if err != nil {
		logger.Error("count err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}
	//total := int(count)/req.PageSize + 1
	resp.Total = int(count)/req.PageSize + 1
	var categories []model.ErpCashier
	err = qs.Order("id DESC").Offset(page * req.PageSize).Limit(req.PageSize).Find(&categories).Error
	if err != nil && err != model.RecordNotFound {
		logger.Error("erp commodity list err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	resp.List = categories
	//ret := map[string]interface{}{
	//	"total":     total,
	//	"page_num":  req.PageNum,
	//	"page_size": req.PageSize,
	//	"list":      categories,
	//}

	app.OK(c, resp, "")
	return
}