package service

import (
	"XT_New/models"
	"fmt"
	"github.com/jinzhu/gorm"
	"strconv"
	"strings"
	"time"
)

func GetDictionaryConfigList(orgID int64) (dataconfig interface{}, err error) {
	var configList []*models.DictionaryDataconfig

	err = readDb.Model(&models.DictionaryDataconfig{}).Where("(org_id in (0,?) and status = 1) or (status = 0 and delete_id_system > 0 and org_id = ?)", orgID, orgID).Order("orders asc, id asc").Find(&configList).Error
	if err != nil {
		return nil, err
	}

	// configResult := make([]*ConfigViewModel,0)
	childConfig := make(map[int64][]*models.DictionaryDataconfig)
	resultConfig := make(map[string][]*models.DictionaryConfigViewModel)
	deleteSystemChilds := make([]*models.DictionaryDataconfig, 0)
	editSystemChilds := make([]*models.DictionaryDataconfig, 0)
	for _, config := range configList {
		if config.Status == 1 && config.DeleteIdSystem > 0 {
			editSystemChilds = append(editSystemChilds, config)
		}

		if config.Status == 0 && config.DeleteIdSystem > 0 {
			deleteSystemChilds = append(deleteSystemChilds, config)
		}
	}
	continueFlag := false
	for _, config := range configList {
		continueFlag = false
		if config.ParentId == 0 {
			newConfig := &models.DictionaryConfigViewModel{
				ID:           config.ID,
				ParentId:     config.ParentId,
				Module:       config.Module,
				OrgId:        config.OrgId,
				Name:         config.Name,
				FieldName:    config.FieldName,
				Value:        config.Value,
				CreateUserId: config.CreateUserId,
				Status:       config.Status,
				Remark:       config.Remark,
				Title:        config.Title,
				Content:      config.Content,
			}
			// configResult = append(configResult,newConfig)
			result := resultConfig[config.Module]
			if result == nil {
				result = make([]*models.DictionaryConfigViewModel, 0)
			}
			for _, vm := range editSystemChilds {
				if vm.DeleteIdSystem == config.ID {
					continueFlag = true
					break
				}
			}

			for _, _vm := range deleteSystemChilds {
				if _vm.DeleteIdSystem == config.ID {
					continueFlag = true
					break
				}
			}
			if config.OrgId != 0 && config.Status == 0 && config.DeleteIdSystem > 0 {
				continue
			}
			if continueFlag {
				continue
			}
			result = append(result, newConfig)
			resultConfig[config.Module] = result
		} else {
			childs := childConfig[config.ParentId]
			if childs == nil {
				childs = make([]*models.DictionaryDataconfig, 0)
			}
			continueFlag := false
			for _, vm := range editSystemChilds {
				if vm.DeleteIdSystem == config.ID {
					continueFlag = true
					break
				}
			}

			for _, _vm := range deleteSystemChilds {
				if _vm.DeleteIdSystem == config.ID {
					continueFlag = true
					break
				}
			}
			if config.OrgId != 0 && config.Status == 0 && config.DeleteIdSystem > 0 {
				continue
			}
			if continueFlag {
				continue
			}

			childs = append(childs, config)
			childConfig[config.ParentId] = childs
		}
	}

	for _, vm := range resultConfig {
		for _, _vm := range vm {
			_vm.Childs = childConfig[_vm.ID]
		}
		// vm.Childs = childConfig[vm.ID]
	}
	return resultConfig, err
}

func CreateDictionaryConfig(dataconfig *models.DictionaryDataconfig) (err error) {
	// readDb.Model(&models.Dataconfig{}).Where("module = ? and parent_id = 0 and org_id in (0,?)",dataconfig.Module,dataconfig.OrgId).Count(&total)
	err = readDb.Create(&dataconfig).Error
	return
}

func GetDictionaryChildValue(module string, parent_id int64, org_id int64) (value int) {
	readDb.Model(&models.DictionaryDataconfig{}).Where("module=? and parent_id=? and org_id in (0,?)", module, parent_id, org_id).Count(&value)
	return
}

func FindDictionaryConfigByTitle(module string, title string, org_id int64) (dataconfig models.DictionaryDataconfig, err error) {
	err = readDb.Model(&models.DictionaryDataconfig{}).Where("module=? and title=? and org_id in (0,?) and status = 1", module, title, org_id).First(&dataconfig).Error
	return
}

func UpdateDictionaryTemplate(dataconfig *models.DictionaryDataconfig) (err error) {
	err = readDb.Model(&models.DictionaryDataconfig{}).Where("id =?", dataconfig.ID).Update(map[string]interface{}{"title": dataconfig.Title, "content": dataconfig.Content, "update_time": dataconfig.UpdatedTime, "remark": dataconfig.Remark}).Error
	return
}

func UpdateDictionaryChildConfig(dataconfig *models.DictionaryDataconfig) (err error) {
	err = readDb.Model(&models.DictionaryDataconfig{}).Where("id =?", dataconfig.ID).Update(map[string]interface{}{"name": dataconfig.Name, "update_time": dataconfig.UpdatedTime, "remark": dataconfig.Remark, "orders": dataconfig.Order, "code": dataconfig.Code}).Error
	return
}

func DeleteDictionaryChildConfig(dataconfig *models.DictionaryDataconfig) (err error) {
	err = readDb.Model(&models.DictionaryDataconfig{}).Where("id =?", dataconfig.ID).Update(map[string]interface{}{"status": dataconfig.Status, "update_time": dataconfig.UpdatedTime}).Error
	return
}

func CreateBaseDrugLib(lib *models.BaseDrugLib) (err error) {
	err = writeDb.Create(&lib).Error
	return
}

func UpdateBaseDrugLib(lib *models.BaseDrugLib) (err error) {
	err = writeDb.Save(lib).Error
	return
}

func FindBaseDrugLibRecordCount(lib *models.BaseDrugLib) (count int64) {
	readDb.Model(&models.BaseDrugLib{}).Where("org_id = ? AND drug_name = ? AND  drug_category = ? AND drug_spec=? AND drug_type=? AND status = 1", lib.OrgId, lib.DrugName, lib.DrugCategory, lib.DrugSpec, lib.DrugType).Count(&count)
	return
}

func FindBaseDrugLibRecordCountOne(lib *models.BaseDrugLib) (count int64) {
	readDb.Model(&models.BaseDrugLib{}).Where("org_id = ? and drug_name = ? and dose = ? and dose_unit = ? and min_number = ? and min_unit = ? and max_unit = ? and manufacturer = ? and status = 1", lib.OrgId, lib.DrugName, lib.Dose, lib.DoseUnit, lib.MinNumber, lib.MinUnit, lib.MaxUnit, lib.Manufacturer).Count(&count)
	return
}

func FindAllDrugLibRecordTotal(org_id int64) (count int64) {
	readDb.Model(&models.BaseDrugLib{}).Where("org_id = ? AND status = 1", org_id).Count(&count)
	return
}

func FindBaseDrugLibRecord(org_id int64, id int64) (lib models.BaseDrugLib, err error) {
	err = readDb.Model(&models.BaseDrugLib{}).Where("id = ? AND org_id = ?  AND status = 1", id, org_id).First(&lib).Error
	return
}

func FindBaseDrugLibRecordSeven(org_id int64, id int64) (lib models.BaseDrugLibSeven, err error) {
	err = readDb.Select("id,drug_name,max_unit,min_number,min_unit,sum_count,is_user,is_pharmacy").Where("org_id = ? AND id = ? AND status = 1", org_id, id).First(&lib).Error
	return
}

func GetDrugAutoWarehouseOut(patient_id int64, advicedate int64, drugid int64) (*models.DrugWarehouseOutInfo, error) {
	detail := models.DrugWarehouseOutInfo{}
	err := XTReadDB().Model(&detail).Where("patient_id = ? and sys_record_time =? and drug_id = ? and status = 1", patient_id, advicedate, drugid).Find(&detail).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &detail, nil
}

func GetDrugAutoWarehouseOutSeven(patient_id int64, advicedate int64, drugid int64, adviceid int64) (*models.DrugWarehouseOutInfo, error) {
	detail := models.DrugWarehouseOutInfo{}
	err := XTReadDB().Model(&detail).Where("patient_id = ? and sys_record_time =? and drug_id = ? and status = 1 and advice_id = ?", patient_id, advicedate, drugid, adviceid).Find(&detail).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &detail, nil
}

func GetDrugAutoWarehouseOutEight(patient_id int64, advicedate int64, drugid int64, adviceid int64) (models.DrugWarehouseOutInfo, error) {
	detail := models.DrugWarehouseOutInfo{}
	err = XTReadDB().Model(&detail).Where("patient_id = ? and sys_record_time =? and drug_id = ? and status = 1 and advice_id = ?", patient_id, advicedate, drugid, adviceid).Find(&detail).Error
	return detail, err
}

func GetDrugAutoWarehouseOutNight(patient_id int64, advicedate int64, drugid int64, adviceid int64) (night []*models.DrugWarehouseOutInfo, err error) {

	err = XTReadDB().Where("patient_id = ? and sys_record_time =? and drug_id = ? and status = 1 and advice_id = ?", patient_id, advicedate, drugid, adviceid).Find(&night).Error
	return night, err
}

func UpdateDrugWarehouse(id int64, info models.DrugWarehouseInfo) error {
	err := writeDb.Model(&models.DrugWarehouseInfo{}).Where("id = ?", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number + ?", info.StockMinNumber)).Error
	return err
}

func UpdateDrugWarehouseOne(id int64, info models.DrugWarehouseInfo) error {
	err := writeDb.Model(&models.DrugWarehouseInfo{}).Where("id = ?", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", info.StockMaxNumber)).Error
	return err
}

func GetBaseDrugLibList(org_id int64, keyword string, page int64, limit int64, is_use int64, is_charge int64, is_inject int64, manufacturer int64, isRecord int64) (list []*models.BaseDrugLib, total int64, err error) {

	db := readDb.Model(&models.BaseDrugLib{}).Where("org_id = ?  AND status = 1", org_id)
	if len(keyword) != 0 {
		keyword = "%" + keyword + "%"
		db = db.Where("drug_name Like ?", keyword)

	}

	if is_use != 0 {
		if is_use == 2 {
			db = db.Where("find_in_set('停用',drug_status) = 0")

		} else {
			db = db.Where("find_in_set('停用',drug_status) > 0")
		}
	}

	if is_charge == 1 {
		//if is_charge == 1 {
		//	db = db.Where("find_in_set('收费',drug_status) > 0")
		//
		//} else {
		//	db = db.Where("find_in_set('收费',drug_status) = 0")
		//}
		db = db.Where("is_record = ?", is_charge)
	}

	if is_charge == 2 {
		db = db.Where("is_record= 0 || is_record = 2")
	}

	if is_inject != 0 {
		//db = db.Where("drug_name Like ?", keyword)
		if is_inject == 1 {
			db = db.Where("find_in_set('注射类',drug_status) > 0")

		} else {
			db = db.Where("find_in_set('注射类',drug_status) = 0")
		}

	}

	if manufacturer > 0 {
		db = db.Where("manufacturer = ?", manufacturer)
	}
	if isRecord > 0 {
		db = db.Where("is_mark = ?", isRecord)
	}
	offset := (page - 1) * limit

	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&list).Error
	return
}

func CreateMedicineInsurancePercentage(mip *models.MedicineInsurancePercentage) (err error) {
	err = writeDb.Create(mip).Error
	return
}

func CreateUnitSafeguard(dus *models.DrugUnitSafeguard) (err error) {
	err = writeDb.Create(dus).Error
	return
}

func AddSigleMZSick(dealer *models.OutpatientServiceSick) (error, *models.OutpatientServiceSick) {
	err := writeDb.Create(&dealer).Error
	return err, dealer
}

func ModifyMZSick(mesick *models.OutpatientServiceSick) error {
	err := writeDb.Save(&mesick).Error

	return err
}

func FindAllMZSickList(orgId int64, page int64, limit int64) (list []*models.OutpatientServiceSick, total int64, err error) {
	offset := (page - 1) * limit
	db := readDb.Model(&models.OutpatientServiceSick{})
	db = db.Where("user_org_id = ? AND status = 1", orgId)
	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&list).Error
	return
}

func DeleteMZSickById(id int64) error {
	err := writeDb.Model(&models.OutpatientServiceSick{}).Where("id = ? AND status = 1", id).Updates(map[string]interface{}{"mtime": time.Now().Unix(), "status": 0}).Error
	return err
}

func FindMZSickById(id int64) (*models.OutpatientServiceSick, error) {
	dealer := &models.OutpatientServiceSick{}
	err := readDb.Model(&models.OutpatientServiceSick{}).Where("id = ? AND status = 1", id).First(&dealer).Error
	return dealer, err
}

func GetDrugWareoutInfo(id int64) (*models.XtDrugWarehouseInfo, error) {

	info := models.XtDrugWarehouseInfo{}
	err = XTReadDB().Model(&info).Where("drug_id = ? and status = 1", id).Find(&info).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &info, nil
}

func GetDrugWareOutById(id int64) (*models.XtDrugWarehouseOutInfo, error) {

	info := models.XtDrugWarehouseOutInfo{}
	err := XTReadDB().Model(&info).Where("drug_id = ? and status = 1", id).Find(&info).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &info, nil
}

func DeleteBaseDrugById(id int64) error {

	drug := models.XtBaseDrug{}
	err := XTWriteDB().Model(&drug).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"status": 0}).Error
	return err
}

func AddSigleAddition(dealer *models.XtHisAddtionConfig) (error, *models.XtHisAddtionConfig) {
	err := writeDb.Create(&dealer).Error
	return err, dealer
}

func ModifyAddition(mesick *models.XtHisAddtionConfig) error {
	err := writeDb.Save(&mesick).Error

	return err
}

func FindAllAdditionList(orgId int64, page int64, limit int64) (list []*models.XtHisAddtionConfig, total int64, err error) {
	offset := (page - 1) * limit
	db := readDb.Model(&models.XtHisAddtionConfig{})
	db = db.Where("user_org_id = ? AND status = 1", orgId)
	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&list).Error
	return
}

func DeleteAdditionById(id int64) error {
	err := writeDb.Model(&models.XtHisAddtionConfig{}).Where("id = ? AND status = 1", id).Updates(map[string]interface{}{"mtime": time.Now().Unix(), "status": 0}).Error
	return err
}

func FindAdditionById(id int64) (*models.XtHisAddtionConfig, error) {
	dealer := &models.XtHisAddtionConfig{}
	err := readDb.Model(&models.XtHisAddtionConfig{}).Where("id = ? AND status = 1", id).First(&dealer).Error
	return dealer, err
}

func AddSigleDiagnose(dealer *models.HisXtDiagnoseConfig) (error, *models.HisXtDiagnoseConfig) {
	err := writeDb.Create(&dealer).Error
	return err, dealer
}

func ModifyDiagnose(mesick *models.HisXtDiagnoseConfig) error {
	err := writeDb.Save(&mesick).Error

	return err
}

func FindAllDiagnoseList(orgId int64, page int64, limit int64) (list []*models.HisXtDiagnoseConfig, total int64, err error) {
	offset := (page - 1) * limit
	db := readDb.Model(&models.HisXtDiagnoseConfig{})
	db = db.Where("user_org_id = ? AND status = 1", orgId)
	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&list).Error
	return
}

func DeleteDiagnoseById(id int64) error {
	err := writeDb.Model(&models.HisXtDiagnoseConfig{}).Where("id = ? AND status = 1", id).Updates(map[string]interface{}{"mtime": time.Now().Unix(), "status": 0}).Error
	return err
}

func FindDiagnoseById(id int64) (*models.HisXtDiagnoseConfig, error) {
	dealer := &models.HisXtDiagnoseConfig{}
	err := readDb.Model(&models.HisXtDiagnoseConfig{}).Where("id = ? AND status = 1", id).First(&dealer).Error
	return dealer, err
}

func GetDoseCode(dose_id int64, user_org_id int64) (error, string) {
	var data models.DictDataconfig
	err := readDb.Model(&models.DictDataconfig{}).Where(" (user_org_id = ? Or user_org_id = 0) AND parent_id = 4 AND module = 'system' AND status = 1 AND value = ?", user_org_id, dose_id).First(&data).Error
	return err, data.Code
}

func GetAllDrugList(orgid int64) (drug []*models.BaseDrugLib, err error) {

	err = XTReadDB().Model(&drug).Where("org_id = ? and status = 1", orgid).Find(&drug).Error
	return drug, err
}

//自动退库分装方法

func DrugAutoAddCancelInfo(advice *models.HisDoctorAdviceInfo, creater int64) error {

	//查询该病人该药品是否有库存记录
	info, _ := GetDrugAutoWarehouseOutEight(advice.PatientId, advice.AdviceDate, advice.DrugId, advice.ID)

	list, _ := GetDrugAutoWarehouseOutNight(advice.PatientId, advice.AdviceDate, advice.DrugId, advice.ID)

	storeHouseConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
	//退库
	drug, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)
	fmt.Println("list223323232233223322323323223", len(list))

	//如果剩余数量 + 退库数量 < 总入库数量
	if len(list) > 0 {
		for _, its := range list {
			//查询该药品出库批次总入库数量
			druginfo, _ := GetDrugInfoSix(its.WarehouseInfoId, info.OrgId)

			var out_count int64  //该批次出库库存
			var sum_count int64  //该批次总库存
			var over_count int64 //剩余数量

			over_count = druginfo.StockMaxNumber*drug.MinNumber + druginfo.StockMinNumber
			if info.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				out_count = info.Count * drug.MinNumber

			}
			if info.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				out_count = info.Count
			}

			if info.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				out_count = info.Count
			}

			if druginfo.MaxUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
				sum_count = druginfo.WarehousingCount * drug.MinNumber
			}

			if druginfo.MaxUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
				sum_count = druginfo.WarehousingCount
			}

			if druginfo.MaxUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
				sum_count = druginfo.WarehousingCount
			}

			fmt.Println("该批次剩余库存", over_count)
			fmt.Println("该批次退库数量", out_count)
			fmt.Println("该批次总入库数量", sum_count)
			if (over_count + out_count) <= sum_count {
				if its.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
					fmt.Println("进来1", its.Count)
					//退库
					warehouseInfo := models.DrugWarehouseInfo{
						StockMinNumber: its.Count,
					}
					UpdateDrugWarehouse(its.WarehouseInfoId, warehouseInfo)
				}
				if its.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
					fmt.Println("进来2", its.Count)
					warehouseInfo := models.DrugWarehouseInfo{
						StockMaxNumber: its.Count,
					}
					UpdateDrugWarehouseOne(its.WarehouseInfoId, warehouseInfo)
				}

				if its.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
					fmt.Println("进来3", its.Count)
					warehouseInfo := models.DrugWarehouseInfo{
						StockMaxNumber: its.Count,
					}
					UpdateDrugWarehouseOne(its.WarehouseInfoId, warehouseInfo)
				}

			}
		}

		floatPrescrip := strconv.FormatFloat(advice.PrescribingNumber, 'f', -1, 32)
		prescribingNumber, _ := strconv.ParseInt(floatPrescrip, 10, 64)

		if advice.PrescribingNumberUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {

			operation_time := time.Now().Unix()

			ctime := time.Now().Unix()
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllDrugCancelStockTotal(advice.UserOrgId)
			total = total + 1
			orderNumber := "CKTKD" + strconv.FormatInt(advice.UserOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)
			cancelStock := models.DrugCancelStock{
				OrderNumber:  orderNumber,
				OperaTime:    operation_time,
				OrgId:        advice.UserOrgId,
				Creater:      creater,
				Ctime:        ctime,
				Status:       1,
				ReturnTime:   advice.AdviceDate,
				Dealer:       info.Dealer,
				Manufacturer: info.Manufacturer,
				Type:         1,
				StorehouseId: storeHouseConfig.DrugStorehouseOut,
				IsCheck:      1,
			}
			AddSigleDrugCancelStock(&cancelStock)

			manufactureName, _ := GetManufactureById(info.Manufacturer)
			dealer, _ := GetDealerById(info.Dealer)
			cancelInfo, _ := GetLastDrugCancelStockById(advice.UserOrgId)
			cancelStockInfo := models.DrugCancelStockInfo{
				OrderNumber:      cancelInfo.OrderNumber,
				CancelStockId:    cancelInfo.ID,
				DrugId:           advice.DrugId,
				Count:            prescribingNumber,
				Status:           1,
				Ctime:            ctime,
				OrgId:            advice.UserOrgId,
				Type:             1,
				Manufacturer:     manufactureName.ManufacturerName,
				Dealer:           dealer.DealerName,
				Total:            0,
				RetailPrice:      info.RetailPrice,
				RetailTotalPrice: info.RetailTotalPrice,
				Price:            info.Price,
				RegisterAccount:  "",
				Remark:           info.Remark,
				BatchNumber:      info.BatchNumber,
				MaxUnit:          advice.PrescribingNumberUnit,
				ProductDate:      info.ProductDate,
				ExpiryDate:       info.ExpiryDate,
				BatchNumberId:    info.WarehouseInfoId,
				StorehouseId:     storeHouseConfig.DrugStorehouseOut,
				IsCheck:          1,
			}

			flow := models.DrugFlow{
				WarehousingId:           0,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   prescribingNumber,
				UserOrgId:               advice.UserOrgId,
				PatientId:               0,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           cancelStock.ID,
				CancelOrderNumber:       cancelStock.OrderNumber,
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     0,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 advice.PrescribingNumberUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            storeHouseConfig.DrugStorehouseOut,
			}
			CreatedCancelStock(cancelStockInfo)
			CreateDrugFlowOne(flow)

			//删除出库记录
			UpdateDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTens(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}
		if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {

			houseConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)

			operation_time := time.Now().Unix()
			ctime := time.Now().Unix()
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllDrugCancelStockTotal(advice.UserOrgId)
			total = total + 1
			orderNumber := "CKTKD" + strconv.FormatInt(advice.UserOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

			cancelStock := models.DrugCancelStock{
				OrderNumber:  orderNumber,
				OperaTime:    operation_time,
				OrgId:        advice.UserOrgId,
				Creater:      creater,
				Ctime:        ctime,
				Status:       1,
				ReturnTime:   advice.AdviceDate,
				Dealer:       info.Dealer,
				Manufacturer: info.Manufacturer,
				Type:         1,
				StorehouseId: houseConfig.DrugStorehouseOut,
				IsCheck:      1,
			}
			AddSigleDrugCancelStock(&cancelStock)

			manufactureName, _ := GetManufactureById(info.Manufacturer)
			dealer, _ := GetDealerById(info.Dealer)
			cancelInfo, _ := GetLastDrugCancelStockById(advice.UserOrgId)
			cancelStockInfo := models.DrugCancelStockInfo{
				OrderNumber:      cancelInfo.OrderNumber,
				CancelStockId:    cancelInfo.ID,
				DrugId:           info.DrugId,
				Count:            prescribingNumber,
				Status:           1,
				Ctime:            ctime,
				OrgId:            advice.UserOrgId,
				Type:             1,
				Manufacturer:     manufactureName.ManufacturerName,
				Dealer:           dealer.DealerName,
				Total:            0,
				RetailPrice:      info.RetailPrice,
				RetailTotalPrice: info.RetailTotalPrice,
				Price:            info.Price,
				RegisterAccount:  "",
				Remark:           info.Remark,
				BatchNumber:      info.BatchNumber,
				MaxUnit:          advice.PrescribingNumberUnit,
				ProductDate:      info.ProductDate,
				ExpiryDate:       info.ExpiryDate,
				BatchNumberId:    info.WarehouseInfoId,
				StorehouseId:     houseConfig.DrugStorehouseOut,
				IsCheck:          1,
			}

			flow := models.DrugFlow{
				WarehousingId:           0,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   prescribingNumber,
				UserOrgId:               advice.UserOrgId,
				PatientId:               0,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           cancelStock.ID,
				CancelOrderNumber:       cancelStock.OrderNumber,
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     0,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 advice.PrescribingNumberUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            houseConfig.DrugStorehouseOut,
			}
			CreatedCancelStock(cancelStockInfo)
			CreateDrugFlowOne(flow)
			//删除出库记录
			UpdateDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTens(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}

		if advice.PrescribingNumberUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {

			houseConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)

			operation_time := time.Now().Unix()
			ctime := time.Now().Unix()
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllDrugCancelStockTotal(advice.UserOrgId)
			total = total + 1
			orderNumber := "CKTKD" + strconv.FormatInt(advice.UserOrgId, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

			cancelStock := models.DrugCancelStock{
				OrderNumber:  orderNumber,
				OperaTime:    operation_time,
				OrgId:        advice.UserOrgId,
				Creater:      creater,
				Ctime:        ctime,
				Status:       1,
				ReturnTime:   advice.AdviceDate,
				Dealer:       info.Dealer,
				Manufacturer: info.Manufacturer,
				Type:         1,
				StorehouseId: houseConfig.DrugStorehouseOut,
				IsCheck:      1,
			}
			AddSigleDrugCancelStock(&cancelStock)

			manufactureName, _ := GetManufactureById(info.Manufacturer)
			dealer, _ := GetDealerById(info.Dealer)
			cancelInfo, _ := GetLastDrugCancelStockById(advice.UserOrgId)
			cancelStockInfo := models.DrugCancelStockInfo{
				OrderNumber:      cancelInfo.OrderNumber,
				CancelStockId:    cancelInfo.ID,
				DrugId:           info.DrugId,
				Count:            prescribingNumber,
				Status:           1,
				Ctime:            ctime,
				OrgId:            advice.UserOrgId,
				Type:             1,
				Manufacturer:     manufactureName.ManufacturerName,
				Dealer:           dealer.DealerName,
				Total:            0,
				RetailPrice:      info.RetailPrice,
				RetailTotalPrice: info.RetailTotalPrice,
				Price:            info.Price,
				RegisterAccount:  "",
				Remark:           info.Remark,
				BatchNumber:      info.BatchNumber,
				MaxUnit:          advice.PrescribingNumberUnit,
				ProductDate:      info.ProductDate,
				ExpiryDate:       info.ExpiryDate,
				BatchNumberId:    info.WarehouseInfoId,
				StorehouseId:     houseConfig.DrugStorehouseOut,
				IsCheck:          1,
			}

			flow := models.DrugFlow{
				WarehousingId:           0,
				DrugId:                  info.DrugId,
				Number:                  "",
				BatchNumber:             info.BatchNumber,
				Count:                   prescribingNumber,
				UserOrgId:               advice.UserOrgId,
				PatientId:               0,
				SystemTime:              info.SysRecordTime,
				ConsumableType:          7,
				IsSys:                   0,
				WarehousingOrder:        "",
				WarehouseOutId:          0,
				WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           cancelStock.ID,
				CancelOrderNumber:       cancelStock.OrderNumber,
				Manufacturer:            info.Manufacturer,
				Dealer:                  info.Dealer,
				Creator:                 creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   info.Price,
				WarehousingDetailId:     0,
				WarehouseOutDetailId:    0,
				CancelOutDetailId:       0,
				ExpireDate:              info.ExpiryDate,
				ProductDate:             info.ProductDate,
				MaxUnit:                 advice.PrescribingNumberUnit,
				MinUnit:                 "",
				AdviceId:                info.AdviceId,
				StorehouseId:            houseConfig.DrugStorehouseOut,
			}
			CreatedCancelStock(cancelStockInfo)
			CreateDrugFlowOne(flow)
			//删除出库记录
			UpdateDrugFlowSeven(info.PatientId, info.SysRecordTime, info.DrugId, advice.ID, info.ID)
			//删除流水
			UpdateDrugFlowTens(info.PatientId, info.WarehouseOutOrderNumber, info.DrugId, advice.ID)
		}

		//更新字典里面的库存
		stockInfo, _ := GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, advice.UserOrgId, advice.DrugId)
		//查询改药品信息
		medical, _ := GetBaseDrugMedical(advice.DrugId)
		var sum_count_one int64
		for _, its := range stockInfo {
			sum_count_one += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
		}
		UpdateBaseDrugSumTwo(advice.DrugId, sum_count_one, advice.UserOrgId)
	}
	return err
}
