XT_New/service/statistis_qc_service.go

package service

import (
	"database/sql"
	"fmt"
	"log"
	"math"
	"reflect"
	"strconv"
	"strings"
	"time"

	"XT_New/models"
	"github.com/jinzhu/gorm"
)

func GetDialysisTotalDatas() {

}

func GetNewDialysiTotal(startime int64, endtime int64, orgid int64, origin int64) (int64, error) {
	counts := models.PatientPrescriptionCountStruct{}
	var err error
	if origin == 1 { //透析记录，上机为准
		db := XTReadDB().Table("xt_dialysis_order as x").Joins("join xt_dialysis_prescription p on p.patient_id = x.patient_id and p.record_date = x.dialysis_date")
		err = db.Select("count(x.id) as count").Where("x.dialysis_date >= ? and x.dialysis_date<=? and x.user_org_id = ? AND x.status = 1 and x.stage = 2", startime, endtime, orgid).Scan(&counts).Error
		return counts.Count, err

	} else {
		var count int64
		var schs []models.Schedule
		db := XTReadDB().Model(&models.Schedule{})
		err := db.
			Group("patient_id, schedule_date").
			Where("schedule_date >= ? AND schedule_date  <= ? and user_org_id = ? and status = 1", startime, endtime, orgid).
			Find(&schs).
			Error
		count = int64(len(schs))
		return count, err

	}

}

type TreatmentMode struct {
	ModeID   int    `json:"mode_id"`
	ModeName string `json:"mode_name"`
}

type DialysisStat struct {
	Date   string         `json:"日期"`
	Counts map[string]int `json:"counts"`
	Total  int            `json:"合计"`
}

func GetTreatmentModes(org_id int64, start string, end string) (mode []models.MewTreatmentMode) {
	//XTReadDB().Model(&models.HisPrescription{}).Joins("join xt_treatment_mode mode on").Where("user_org_id = ?", org_id).Find(&modes).Error
	XTReadDB().Table("xt_dialysis_prescription p").Joins("join xt_treatment_mode mode on mode.id = p.mode_id").Where("p.user_org_id = ? and  FROM_UNIXTIME(p.record_date) >= ? AND FROM_UNIXTIME(p.record_date) <= ?", org_id, start, end).Select("mode.name as name, p.mode_id as mode_id").Group("p.mode_id").Scan(&mode)
	return
}

func GetDialysisStats(start int64, end int64, mode int64, org_id int64, time_way int64) ([]map[string]interface{}, error) {
	// 将时间戳转换为time.Time类型
	t := time.Unix(start, 0)
	// 使用布局定义格式化时间
	layout := "2006-01-02"
	// 将时间格式化为字符串
	startDate := t.Format(layout) + " 00:00:00"

	t2 := time.Unix(end, 0)
	// 使用布局定义格式化时间
	//layout := "2006-01-02"
	// 将时间格式化为字符串
	endDate := t2.Format(layout) + " 00:00:00"
	//var stats []DialysisStat
	var modes []models.MewTreatmentMode
	fmt.Println(mode)
	if mode == 0 {
		modes = GetTreatmentModes(org_id, startDate, endDate)

	} else {
		modes_two := GetTreatmentModes(org_id, startDate, endDate)
		for _, item := range modes_two {
			if item.ModeID == mode {
				modes = append(modes, item)
			}
		}
	}
	// 获取透析模式
	if err != nil {
		return nil, err
	}

	var selectClauses []string
	// 构建动态查询语句
	if time_way == 1 {
		//selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(startDate, " ")[0])}
		selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(startDate, " ")[0])}

	} else if time_way == 3 {
		selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(startDate, " ")[0]+"~"+strings.Split(endDate, " ")[0])}

		//selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(strings.Split(startDate, " ")[0], "-")[0]+"-"+strings.Split(strings.Split(startDate, " ")[0], "-")[1])}
	} else if time_way == 4 {
		selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(startDate, " ")[0]+"~"+strings.Split(endDate, " ")[0])}

		//selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(strings.Split(startDate, " ")[0], "-")[0])}
	} else {
		selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(startDate, " ")[0]+"~"+strings.Split(endDate, " ")[0])}
	}
	for _, mode := range modes {
		fmt.Println(mode)

		selectClauses = append(selectClauses, fmt.Sprintf("COALESCE(SUM(CASE WHEN t.name = '%s' THEN 1 ELSE 0 END), 0) AS `%s`", mode.Name, mode.Name))
	}
	selectClauses = append(selectClauses, "COUNT(*) AS `合计`")

	var rows *sql.Rows
	var query string
	if mode > 0 {
		query = fmt.Sprintf(`
        SELECT
            %s
        FROM
            xt_dialysis_prescription p
        JOIN
            xt_treatment_mode t ON p.mode_id = t.mode_id
        WHERE
            FROM_UNIXTIME(p.record_date) >= ? AND FROM_UNIXTIME(p.record_date) <= ? AND p.user_org_id = ? and p.mode_id = ? and p.status=1
        GROUP BY
           日期
    `, strings.Join(selectClauses, ", "))
		rows, _ = readDb.Raw(query, startDate, endDate, org_id, mode).Rows()

	} else {
		query = fmt.Sprintf(`
        SELECT
            %s
        FROM
            xt_dialysis_prescription p
        JOIN
            xt_treatment_mode t ON p.mode_id = t.mode_id
        WHERE
            FROM_UNIXTIME(p.record_date) >= ? AND FROM_UNIXTIME(p.record_date) <= ? AND p.user_org_id = ? and p.status=1
        GROUP BY
           日期
    `, strings.Join(selectClauses, ", "))
		rows, _ = readDb.Raw(query, startDate, endDate, org_id).Rows()
	}

	if err != nil {
		return nil, err
	}
	defer rows.Close()

	columns, err := rows.Columns()
	if err != nil {
		return nil, err
	}

	var results []map[string]interface{}

	for rows.Next() {
		// 创建一个长度为列数的切片，用于存储每一行的值
		columnValues := make([]interface{}, len(columns))
		columnPointers := make([]interface{}, len(columns))
		for i := range columnValues {
			columnPointers[i] = &columnValues[i]
		}

		// 扫描当前行的值
		if err := rows.Scan(columnPointers...); err != nil {
			return nil, err
		}

		// 将扫描到的值放入结果 map 中
		result := make(map[string]interface{})
		for i, colName := range columns {
			val := columnPointers[i].(*interface{})
			result[colName] = *val
		}

		results = append(results, result)
	}

	//// 解析查询结果
	//for rows.Next() {
	//	var stat DialysisStat
	//	stat.Counts = make(map[string]int)
	//	cols := []interface{}{&stat.Date}
	//	for _, mode := range modes {
	//		var count int
	//		cols = append(cols, &count)
	//		stat.Counts[mode.Name] = count
	//	}
	//	var total int
	//	cols = append(cols, &total)
	//	stat.Total = total
	//	if err := rows.Scan(cols...); err != nil {
	//		return nil, err
	//	}
	//	stats = append(stats, stat)
	//}

	return results, nil
}

func GetScheduleStats(start int64, end int64, mode int64, org_id int64, time_way int64) ([]map[string]interface{}, error) {
	// 将时间戳转换为time.Time类型
	t := time.Unix(start, 0)
	// 使用布局定义格式化时间
	layout := "2006-01-02"
	// 将时间格式化为字符串
	startDate := t.Format(layout) + " 00:00:00"

	t2 := time.Unix(end, 0)
	// 使用布局定义格式化时间
	//layout := "2006-01-02"
	// 将时间格式化为字符串
	endDate := t2.Format(layout) + " 00:00:00"
	//var stats []DialysisStat
	var modes []models.MewTreatmentMode
	fmt.Println(mode)
	if mode == 0 {
		modes = GetTreatmentModes(org_id, startDate, endDate)

	} else {
		modes_two := GetTreatmentModes(org_id, startDate, endDate)
		for _, item := range modes_two {
			if item.ModeID == mode {
				modes = append(modes, item)
			}
		}
	}
	// 获取透析模式
	if err != nil {
		return nil, err
	}

	var selectClauses []string
	// 构建动态查询语句
	if time_way == 1 {
		selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(startDate, " ")[0])}
	} else if time_way == 3 {
		selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(strings.Split(startDate, " ")[0], "-")[0]+strings.Split(strings.Split(startDate, " ")[0], "-")[1])}
	} else if time_way == 4 {
		selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(strings.Split(startDate, " ")[0], "-")[0])}
	} else {
		selectClauses = []string{fmt.Sprintf("'%s' AS `日期`", strings.Split(startDate, " ")[0]+"~"+strings.Split(endDate, " ")[0])}
	}
	for _, mode := range modes {
		fmt.Println(mode)

		selectClauses = append(selectClauses, fmt.Sprintf("COALESCE(SUM(CASE WHEN t.name = '%s' THEN 1 ELSE 0 END), 0) AS `%s`", mode.Name, mode.Name))
	}
	selectClauses = append(selectClauses, "COUNT(*) AS `合计`")

	var rows *sql.Rows
	var query string
	if mode > 0 {
		query = fmt.Sprintf(`
        SELECT
            %s
        FROM
            xt_schedule p
        JOIN
            xt_treatment_mode t ON p.mode_id = t.mode_id
        WHERE
            FROM_UNIXTIME(p.schedule_date) >= ? AND FROM_UNIXTIME(p.schedule_date) <= ? AND p.user_org_id = ? and p.mode_id = ? and p.status = 1
        GROUP BY
           日期
    `, strings.Join(selectClauses, ", "))
		rows, _ = readDb.Raw(query, startDate, endDate, org_id, mode).Rows()

	} else {
		query = fmt.Sprintf(`
        SELECT
            %s
        FROM
            xt_schedule p
        JOIN
            xt_treatment_mode t ON p.mode_id = t.mode_id
        WHERE
            FROM_UNIXTIME(p.schedule_date) >= ? AND FROM_UNIXTIME(p.schedule_date) <= ? AND p.user_org_id = ? and p.status = 1
        GROUP BY
           日期
    `, strings.Join(selectClauses, ", "))
		rows, _ = readDb.Raw(query, startDate, endDate, org_id).Rows()
	}

	if err != nil {
		return nil, err
	}
	defer rows.Close()

	columns, err := rows.Columns()
	if err != nil {
		return nil, err
	}

	var results []map[string]interface{}

	for rows.Next() {
		// 创建一个长度为列数的切片，用于存储每一行的值
		columnValues := make([]interface{}, len(columns))
		columnPointers := make([]interface{}, len(columns))
		for i := range columnValues {
			columnPointers[i] = &columnValues[i]
		}

		// 扫描当前行的值
		if err := rows.Scan(columnPointers...); err != nil {
			return nil, err
		}

		// 将扫描到的值放入结果 map 中
		result := make(map[string]interface{})
		for i, colName := range columns {
			val := columnPointers[i].(*interface{})
			result[colName] = *val
		}

		results = append(results, result)
	}

	//// 解析查询结果
	//for rows.Next() {
	//	var stat DialysisStat
	//	stat.Counts = make(map[string]int)
	//	cols := []interface{}{&stat.Date}
	//	for _, mode := range modes {
	//		var count int
	//		cols = append(cols, &count)
	//		stat.Counts[mode.Name] = count
	//	}
	//	var total int
	//	cols = append(cols, &total)
	//	stat.Total = total
	//	if err := rows.Scan(cols...); err != nil {
	//		return nil, err
	//	}
	//	stats = append(stats, stat)
	//}

	return results, nil
}

//func GetScheduleStats(startDate int64, endDate int64, groupBy int64, mode int64, org_id int64) ([]DialysisStat, error) {
//	var stats []DialysisStat
//	var modes []models.TreatmentMode
//	if mode > 0 {
//		modes, _ = GetTreatmentModes()
//	} else {
//		modes_two, _ := GetTreatmentModes()
//		for _, item := range modes_two {
//			if item.ModeID == mode {
//				modes = append(modes, item)
//			}
//		}
//	}
//	// 获取透析模式
//	if err != nil {
//		return nil, err
//	}
//
//	// 构建日期格式
//	dateFormat := "%Y-%m-%d"
//	switch groupBy {
//	case 2:
//		dateFormat = "%Y-%m-%d"
//	case 1:
//		dateFormat = "%Y-%u"
//	case 3:
//		dateFormat = "%Y-%m"
//	case 4:
//		dateFormat = "%Y"
//	default:
//		return nil, fmt.Errorf("invalid group by option")
//	}
//	// 构建动态查询语句
//	selectClauses := []string{fmt.Sprintf("DATE_FORMAT(p.schudle_date, '%s') AS `日期`", dateFormat)}
//	for _, mode := range modes {
//		selectClauses = append(selectClauses, fmt.Sprintf("SUM(CASE WHEN t.mode_name = '%s' THEN 1 ELSE 0 END) AS `%s`", mode.Name, mode.Name))
//	}
//	selectClauses = append(selectClauses, "COUNT(*) AS `合计`")
//
//	query := fmt.Sprintf(`
//        SELECT
//            %s
//        FROM
//            xt_schedule p
//        JOIN
//            xt_treatment_mode t ON p.mode_id = t.mode_id
//        WHERE
//            p.schedule_date >= ? AND p.schedule_date <= ?
//        GROUP BY
//            DATE_FORMAT(p.schedule_date, '%s')
//    `, dateFormat, dateFormat, selectClauses)
//
//	rows, err := readDb.Raw(query, startDate, endDate).Rows()
//	if err != nil {
//		return nil, err
//	}
//	defer rows.Close()
//
//	// 解析查询结果
//	for rows.Next() {
//		var stat DialysisStat
//		stat.Counts = make(map[string]int)
//		cols := []interface{}{&stat.Date}
//		for _, mode := range modes {
//			var count int
//			cols = append(cols, &count)
//			stat.Counts[mode.Name] = count
//		}
//		var total int
//		cols = append(cols, &total)
//		stat.Total = total
//		if err := rows.Scan(cols...); err != nil {
//			return nil, err
//		}
//		stats = append(stats, stat)
//	}
//
//	return stats, nil
//}

func GetNewDialysisCountMode(starttime int64, endtime int64, orgid int64, origin int64, mode_id int64) (counts []*models.PatientPrescriptionCountStruct, err error) {
	if origin == 1 {

		db := readDb.Table("xt_dialysis_order as o").Where("o.status = 1")
		if starttime > 0 {
			db = db.Where("o.dialysis_date >=?", starttime)
		}
		if endtime > 0 {
			db = db.Where("o.dialysis_date<=?", endtime)
		}
		if orgid > 0 {
			db = db.Where("o.user_org_id = ?", orgid)
		}
		db = db.Where("o.stage = 2")
		if mode_id == 0 {
			err = db.Select("s.mode_id,count(s.mode_id) as count").Joins("join xt_dialysis_prescription as s on s.patient_id = o.patient_id and s.record_date = o.dialysis_date and s.status= 1 AND s.record_date >= ? AND s.record_date <= ? AND  s.mode_id > 0", starttime, endtime).Group("s.mode_id").Scan(&counts).Error

		} else {

			err = db.Select("s.mode_id,count(s.mode_id) as count").Joins("join xt_dialysis_prescription as s on s.patient_id = o.patient_id and s.record_date = o.dialysis_date and s.status= 1 AND s.record_date >= ? AND s.record_date <= ? AND  s.mode_id = ? ", starttime, endtime, mode_id).Group("s.mode_id").Scan(&counts).Error

		}
		return counts, err

	} else {
		err = readDb.Raw("select mode_id, count(aa.`mode_id`) as count from xt_schedule aa join (SELECT DISTINCT o.patient_id, o.`schedule_date` FROM xt_schedule AS o WHERE o.status = 1 AND o.schedule_date >= ?   AND o.schedule_date <= ?   AND o.user_org_id = ?) as b on  aa.`patient_id` = b.`patient_id` and aa.`schedule_date` = b.`schedule_date` where aa.`status` = 1 and    aa.schedule_date >= ?    AND aa.schedule_date <= ?   AND aa.user_org_id = ? Group by aa.`mode_id`", starttime, endtime, orgid, starttime, endtime, orgid).Find(&counts).Error
		return counts, err

	}

}

func GetNewDialysisCountModeTwo(starttime int64, endtime int64, orgid int64, origin int64, mode_id int64) (counts models.CustomDialysisData, err error) {

	// 将时间戳转换为time.Time类型
	t := time.Unix(starttime, 0)

	// 使用布局定义格式化时间
	layout := "2006-01-02"

	// 将时间格式化为字符串
	startDate := t.Format(layout) + " 00:00:00"

	t2 := time.Unix(endtime, 0)

	// 使用布局定义格式化时间
	//layout := "2006-01-02"

	// 将时间格式化为字符串
	endDate := t2.Format(layout) + " 00:00:00"
	//fmt.Println(formattedDate)

	// 将日期字符串解析为time.Time类型
	//start, _ := time.Parse("2006-01-02 15:04:05", formattedDate)
	//starttime = start.Unix()
	//fmt.Println(starttime)

	if origin == 1 {
		db := readDb.Table("xt_dialysis_order as o").Where("o.status = 1")
		if starttime > 0 {
			db = db.Where("DATE_FORMAT(FROM_UNIXTIME(o.dialysis_date), '%Y-%m-%d %H:%i:%s') >= ?", startDate)
		}
		if endtime > 0 {
			db = db.Where("DATE_FORMAT(FROM_UNIXTIME(o.dialysis_date), '%Y-%m-%d %H:%i:%s') <= ?", endDate)
		}
		if orgid > 0 {
			db = db.Where("o.user_org_id = ?", orgid)
		}
		db = db.Where("o.stage = 2")

		err = db.Select("s.mode_id,count(s.mode_id) as count").Joins("join xt_dialysis_prescription as s on s.patient_id = o.patient_id and s.record_date = o.dialysis_date and s.status= 1 AND DATE_FORMAT(FROM_UNIXTIME(s.record_date), '%Y-%m-%d %H:%i:%s') >= ?  AND DATE_FORMAT(FROM_UNIXTIME(s.record_date), '%Y-%m-%d %H:%i:%s') <= ? AND  s.mode_id = ? ", startDate, endDate, mode_id).Group("s.mode_id").Scan(&counts).Error
		return counts, err

	} else {
		db := readDb.Table("xt_schedule as o").Where("o.status = 1").Select("patient_id, schedule_date").Group("mode_id")
		if starttime > 0 {
			db = db.Where("DATE_FORMAT(FROM_UNIXTIME(o.schedule_date),'%Y-%m-%d %H:%i:%s') >= ?", startDate)
		}
		if endtime > 0 {
			db = db.Where("DATE_FORMAT(FROM_UNIXTIME(o.schedule_date),'%Y-%m-%d %H:%i:%s') <= ?", endDate)
		}
		if orgid > 0 {
			db = db.Where("o.user_org_id = ?", orgid)
		}
		if mode_id > 0 {
			db = db.Where("o.mode_id = ?", mode_id)
		}

		err = db.Select("o.mode_id,count(o.mode_id) as count").Scan(&counts).Error
		return counts, err

	}

}

var anticoagulantMap = map[int]string{
	1:  "无肝素",
	2:  "普通肝素",
	3:  "低分子肝素",
	4:  "阿加曲班",
	5:  "枸橼酸钠",
	6:  "低分子肝素钙",
	7:  "低分子肝素钠",
	8:  "依诺肝素",
	9:  "达肝素",
	10: "体外抗凝",
	11: "那屈肝素",
	12: "无抗凝剂",
	13: "那屈肝素钙",
	14: "肝素钙注射液",
	15: "甲磺酸萘莫司他",
	16: "低分子量肝素钙",
	17: "肝素钠",
}

func GetAnticoagulantData(start_time int64, end_time int64, org_id int64) (map[string]int, error) {
	var results []struct {
		Anticoagulant int
		Count         int
	}

	err := XTReadDB().Model(&models.DialysisPrescription{}).Joins("join xt_dialysis_order oo on oo.patient_id = xt_dialysis_prescription.patient_id and oo.dialysis_date = xt_dialysis_prescription.record_date and oo.status = 1").
		Select("xt_dialysis_prescription.anticoagulant, COUNT(*) as count").
		Where("xt_dialysis_prescription.status = 1 and xt_dialysis_prescription.record_date >= ? and xt_dialysis_prescription.record_date <= ? and xt_dialysis_prescription.user_org_id = ?", start_time, end_time, org_id).
		Group("xt_dialysis_prescription.anticoagulant").
		Scan(&results).Error
	if err != nil {
		return nil, err
	}
	anticoagulantData := make(map[string]int)
	for _, result := range results {
		if name, ok := anticoagulantMap[result.Anticoagulant]; ok {
			anticoagulantData[name] = result.Count
		}
		//else {
		//	anticoagulantData[fmt.Sprintf("Unknown (%d)", result.Anticoagulant)] = result.Count
		//}z
	}

	return anticoagulantData, nil
}
func GetAnticoagulantTotal(start_time int64, end_time int64, org_id int64) (total int64, err error) {
	err = XTReadDB().Model(&models.DialysisPrescription{}).Joins("join xt_dialysis_order oo on oo.patient_id = xt_dialysis_prescription.patient_id and oo.dialysis_date = xt_dialysis_prescription.record_date and oo.status = 1").
		Where("xt_dialysis_prescription.record_date >= ? and xt_dialysis_prescription.record_date <= ? and xt_dialysis_prescription.user_org_id = ? and xt_dialysis_prescription.status = 1", start_time, end_time, org_id).
		Count(&total).Error

	return
}
func GetDialyzerSummary(org_id int64) ([]models.DialysisPrescription, error) {
	var Dialyzer []models.DialysisPrescription
	err := XTReadDB().Model(&models.DialysisPrescription{}).
		Select("dialysis_dialyszers").
		Where(" user_org_id = ? and status = 1 and dialysis_dialyszers <> ''", org_id).
		Group("dialysis_dialyszers").
		Find(&Dialyzer).Error
	if err != nil {
		return nil, err
	}
	return Dialyzer, nil
}

func GetIrrigationSummary(org_id int64) ([]models.DialysisPrescription, error) {
	var Dialyzer []models.DialysisPrescription

	err := XTReadDB().Model(&models.DialysisPrescription{}).
		Select("dialysis_irrigation").
		Where(" user_org_id = ? and status = 1 and dialysis_irrigation <> ''", org_id).
		Group("dialysis_irrigation").
		Find(&Dialyzer).Error
	if err != nil {
		return nil, err
	}
	return Dialyzer, nil
}

func GetDialysisStrainerSummary(org_id int64) ([]models.DialysisPrescription, error) {
	var Dialyzer []models.DialysisPrescription

	err := XTReadDB().Model(&models.DialysisPrescription{}).
		Select("dialysis_strainer").
		Where(" user_org_id = ? and status = 1 and dialysis_strainer <> ''", org_id).
		Group("dialysis_strainer").
		Find(&Dialyzer).Error
	if err != nil {
		return nil, err
	}
	return Dialyzer, nil
}

type DialyzerResult struct {
	Dialyzer string
	Count    int
}

func GetDialyzerData(start_time int64, end_time int64, org_id int64) (dr []DialyzerResult, err error) {
	err = XTReadDB().Model(&models.DialysisPrescription{}).Joins("join xt_dialysis_order oo on oo.patient_id = xt_dialysis_prescription.patient_id and oo.dialysis_date = xt_dialysis_prescription.record_date and oo.status = 1").
		Select("xt_dialysis_prescription.dialysis_dialyszers as dialyzer, COUNT(*) as count").
		Where("xt_dialysis_prescription.record_date >= ? and xt_dialysis_prescription.record_date <= ? and xt_dialysis_prescription.user_org_id = ? and xt_dialysis_prescription.status = 1 and xt_dialysis_prescription.dialysis_dialyszers <> ''", start_time, end_time, org_id).
		Group("xt_dialysis_prescription.dialysis_dialyszers").
		Scan(&dr).Error
	return
}

func GetDialysisIrrigationData(start_time int64, end_time int64, org_id int64) (dr []DialyzerResult, err error) {
	err = XTReadDB().Model(&models.DialysisPrescription{}).Joins("join xt_dialysis_order oo on oo.patient_id = xt_dialysis_prescription.patient_id and oo.dialysis_date = xt_dialysis_prescription.record_date and oo.status = 1").
		Select("xt_dialysis_prescription.dialysis_irrigation as dialyzer, COUNT(*) as count").
		Where("xt_dialysis_prescription.record_date >= ? and xt_dialysis_prescription.record_date <= ? and xt_dialysis_prescription.user_org_id = ? and xt_dialysis_prescription.status = 1 and xt_dialysis_prescription.dialysis_irrigation <> '' ", start_time, end_time, org_id).
		Group("xt_dialysis_prescription.dialysis_irrigation").
		Scan(&dr).Error
	return
}

func GetDialysisStrainerData(start_time int64, end_time int64, org_id int64) (dr []DialyzerResult, err error) {
	err = XTReadDB().Model(&models.DialysisPrescription{}).Joins("join xt_dialysis_order oo on oo.patient_id = xt_dialysis_prescription.patient_id and oo.dialysis_date = xt_dialysis_prescription.record_date and oo.status = 1").
		Select("xt_dialysis_prescription.dialysis_strainer as dialyzer, COUNT(*) as count").
		Where("xt_dialysis_prescription.record_date >= ? and xt_dialysis_prescription.record_date <= ? and xt_dialysis_prescription.user_org_id = ? and xt_dialysis_prescription.status = 1 and xt_dialysis_prescription.dialysis_strainer <> ''", start_time, end_time, org_id).
		Group("xt_dialysis_prescription.dialysis_strainer").
		Scan(&dr).Error
	return
}

func GetIrrigationData(start_time int64, end_time int64, org_id int64) (dr []DialyzerResult, err error) {
	err = XTReadDB().Model(&models.DialysisPrescription{}).
		Select("dialysis_irrigation as dialyzer, COUNT(*) as count").
		Where("record_date >= ? and record_date <= ? and user_org_id = ? and status = 1", start_time, end_time, org_id).
		Group("dialysis_irrigation").
		Scan(&dr).Error
	return
}

func GetDialyzerTotal(start_time int64, end_time int64, org_id int64) (total int64, err error) {
	err = XTReadDB().Model(&models.DialysisPrescription{}).Joins("join xt_dialysis_order oo on oo.patient_id = xt_dialysis_prescription.patient_id and oo.dialysis_date = xt_dialysis_prescription.record_date and oo.status = 1").
		Where("xt_dialysis_prescription.status = 1 and xt_dialysis_prescription.record_date >= ? and xt_dialysis_prescription.record_date <= ? and xt_dialysis_prescription.user_org_id = ?", start_time, end_time, org_id).
		Count(&total).Error
	return
}

func GetPrescriptionByAnticoagulant(page int64, limit int64, orgid int64, anticoagulant int64, start_time int64, end_time int64) (solution []*models.DialysisPrescription, total int64, err error) {

	db := XTReadDB().Model(&models.DialysisPrescription{}).Joins("join xt_dialysis_order oo on oo.patient_id = xt_dialysis_prescription.patient_id and oo.dialysis_date = xt_dialysis_prescription.record_date and oo.status = 1").Preload("QCPatients", "xt_patients.status = 1 and xt_patients.user_org_id = ?", orgid).Where("xt_dialysis_prescription.status = 1")
	if anticoagulant > 0 {
		db = db.Where("xt_dialysis_prescription.anticoagulant = ?", anticoagulant)
	}
	if orgid > 0 {
		db = db.Where("xt_dialysis_prescription.user_org_id = ?", orgid)
	}
	db = db.Where("xt_dialysis_prescription.record_date >= ? and xt_dialysis_prescription.record_date <= ?", start_time, end_time)

	offset := (page - 1) * limit

	err = db.Count(&total).Offset(offset).Limit(limit).Find(&solution).Error
	return solution, total, err
}

func GetPrescriptionByDialyzer(page int64, limit int64, orgid int64, dialyzer string, start_time int64, end_time int64) (solution []*models.DialysisPrescription, total int64, err error) {

	db := XTReadDB().Model(&models.DialysisPrescription{}).Joins("join xt_dialysis_order oo on oo.patient_id = xt_dialysis_prescription.patient_id and oo.dialysis_date = xt_dialysis_prescription.record_date and oo.status = 1").Preload("QCPatients", "xt_patients.status = 1 and xt_patients.user_org_id = ?", orgid).Where("xt_dialysis_prescription.status = 1")
	if len(dialyzer) > 0 {
		db = db.Where("xt_dialysis_prescription.dialysis_dialyszers = ? or xt_dialysis_prescription.dialysis_irrigation = ? or xt_dialysis_prescription.dialysis_strainer = ?", dialyzer, dialyzer, dialyzer)
	}
	if orgid > 0 {
		db = db.Where("xt_dialysis_prescription.user_org_id = ?", orgid)
	}
	db = db.Where("xt_dialysis_prescription.record_date >= ? and xt_dialysis_prescription.record_date <= ? and xt_dialysis_prescription.status = 1", start_time, end_time)

	offset := (page - 1) * limit

	err = db.Count(&total).Offset(offset).Limit(limit).Find(&solution).Error
	return solution, total, err
}

type DialysisData struct {
	DialysisStatus string `json:"dialysis_status"`
	Count          int    `json:"count"`
}

type CustomData struct {
	DialysisNo       string
	PatientName      string
	DialysisDate     string
	DialysisDuration string
	ActualDuration   string
	Diff             string
	Doctor           string
	Nurse            string
}

func GetDialysisCompletionRate(org_id int64, start_time int64, end_time int64) (map[string]int, error) {
	var results []DialysisData
	query := `
        SELECT
            CASE
                WHEN ABS(TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0))) <= 15 THEN '达到透析处方时间'
                WHEN TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0)) < -15 THEN '超出处方时间'
                ELSE '未达到处方时间'
            END AS dialysis_status,
            COUNT(*) AS count
        FROM
            xt_dialysis_order o
        JOIN
            xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?
        JOIN
            xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?
        WHERE
            o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ?
        GROUP BY
            dialysis_status;
    `
	if err := readDb.Raw(query, org_id, org_id, org_id, start_time, end_time).Scan(&results).Error; err != nil {
		return nil, err
	}
	dialysisCompletionRate := make(map[string]int)
	for _, result := range results {
		dialysisCompletionRate[result.DialysisStatus] = result.Count
	}
	return dialysisCompletionRate, nil
}
func GetDialysisCompletionTotal(org_id int64, start_time int64, end_time int64) (int64, error) {
	var Count int64
	query := `
        SELECT
            COUNT(*) AS count
        FROM
            xt_dialysis_order o
        JOIN
            xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?
        JOIN
            xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?
        WHERE
            o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ?
    `
	if err := readDb.Raw(query, org_id, org_id, org_id, start_time, end_time).Count(&Count).Error; err != nil {
		return 0, err
	}

	return Count, nil
}
func GetDialysisCompletionDetail(org_id int64, start_time int64, end_time int64, mode int64, limit int64, page int64) (results []interface{}, total int64, err error) {
	var query string
	if mode == 0 {
		query = `
	   SELECT
	      pp.dialysis_no as dialysis_no,
	    	pp.name as patient_name,
	      FROM_UNIXTIME(o.dialysis_date) as dialysis_date,
	      CONCAT(p.dialysis_duration_hour, 'h', p.dialysis_duration_minute,'min') as dialysis_duration,
	      CONCAT(a.actual_treatment_hour, 'h', a.actual_treatment_minute,'min') as actual_duration,
	      ABS(TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0))) as diff,
	      p.prescription_doctor as doctor,
	      o.finish_nurse as nurse,
	    	pp.id_card_no as id_card_no
	   FROM
	       xt_dialysis_order o
		JOIN
	       xt_patients pp ON o.patient_id = pp.id AND pp.user_org_id = ?
	   JOIN
	       xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?
	   JOIN
	       xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?
	   WHERE
	       o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ?
	`

		readDb.Table("xt_dialysis_order o").
			Joins("JOIN xt_patients pp ON o.patient_id = pp.id AND pp.user_org_id = ?", org_id).
			Joins("JOIN xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?", org_id).
			Joins("JOIN xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?", org_id).
			Where("o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ?", org_id, start_time, end_time).Count(&total)

	} else if mode == 1 {
		query = `
	   SELECT
	      pp.dialysis_no as dialysis_no,
	      pp.name as patient_name,
	      FROM_UNIXTIME(o.dialysis_date) as dialysis_date,
	      CONCAT(p.dialysis_duration_hour, 'h', p.dialysis_duration_minute,'min') as dialysis_duration,
	      CONCAT(a.actual_treatment_hour, 'h', a.actual_treatment_minute,'min') as actual_duration,
	      ABS(TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0))) as diff,
	      p.prescription_doctor as doctor,
	      o.finish_nurse as nurse,
	   pp.id_card_no as id_card_no
	      
	   FROM
	       xt_dialysis_order o
		JOIN
	       xt_patients pp ON o.patient_id = pp.id AND pp.user_org_id = ?
	   JOIN
	       xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?
	   JOIN
	       xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?
	   WHERE
	       o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ? AND ABS(TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0))) <= 15
	`
		readDb.Table("xt_dialysis_order o").
			Joins("JOIN xt_patients pp ON o.patient_id = pp.id AND pp.user_org_id = ?", org_id).
			Joins("JOIN xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?", org_id).
			Joins("JOIN xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?", org_id).
			Where("o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ? and ABS(TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0))) <= 15", org_id, start_time, end_time).Count(&total)

	} else if mode == 2 {
		query = `
	   SELECT
	      pp.dialysis_no as dialysis_no,
	      pp.name as patient_name,
	      FROM_UNIXTIME(o.dialysis_date) as dialysis_date,
	      CONCAT(p.dialysis_duration_hour, 'h', p.dialysis_duration_minute,'min') as dialysis_duration,
	      CONCAT(a.actual_treatment_hour, 'h', a.actual_treatment_minute,'min') as actual_duration,
	      ABS(TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0))) as diff,
	      p.prescription_doctor as doctor,
	      o.finish_nurse as nurse,
	   pp.id_card_no as id_card_no
	   FROM
	       xt_dialysis_order o
		JOIN
	       xt_patients pp ON o.patient_id = pp.id AND pp.user_org_id = ?
	   JOIN
	       xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?
	   JOIN
	       xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?
	   WHERE
	       o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ? AND TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0)) < -15
	`
		readDb.Table("xt_dialysis_order o").
			Joins("JOIN xt_patients pp ON o.patient_id = pp.id AND pp.user_org_id = ?", org_id).
			Joins("JOIN xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?", org_id).
			Joins("JOIN xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?", org_id).
			Where("o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ? and TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0)) < 0", org_id, start_time, end_time).Count(&total)

	} else if mode == 3 {
		query = `
	   SELECT
	      pp.dialysis_no as dialysis_no,
	      pp.name as patient_name,
	      FROM_UNIXTIME(o.dialysis_date) as dialysis_date,
	      CONCAT(p.dialysis_duration_hour, 'h', p.dialysis_duration_minute,'min') as dialysis_duration,
	      CONCAT(a.actual_treatment_hour, 'h', a.actual_treatment_minute,'min') as actual_duration,
	      ABS(TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0))) as diff,
	      p.prescription_doctor as doctor,
	      o.finish_nurse as nurse,
	   pp.id_card_no as id_card_no
	   FROM
	       xt_dialysis_order o
		JOIN
	       xt_patients pp ON o.patient_id = pp.id AND pp.user_org_id = ?
	   JOIN
	       xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?
	   JOIN
	       xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?
	   WHERE
	       o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ? AND TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0)) > 15
	`
		readDb.Table("xt_dialysis_order o").
			Joins("JOIN xt_patients pp ON o.patient_id = pp.id AND pp.user_org_id = ?", org_id).
			Joins("JOIN xt_dialysis_prescription p ON o.dialysis_date = p.record_date AND o.patient_id = p.patient_id AND p.user_org_id = ?", org_id).
			Joins("JOIN xt_assessment_after_dislysis a ON o.dialysis_date = a.assessment_date AND o.patient_id = a.patient_id AND a.user_org_id = ?", org_id).
			Where("o.stage = 2 AND o.user_org_id = ? AND o.dialysis_date >= ? AND o.dialysis_date <= ? and TIMESTAMPDIFF(MINUTE, MAKETIME(p.dialysis_duration_hour, p.dialysis_duration_minute, 0), MAKETIME(a.actual_treatment_hour, a.actual_treatment_minute, 0)) > 15", org_id, start_time, end_time).Count(&total)

	}

	offset := (page - 1) * limit

	rows, err := readDb.Raw(query, org_id, org_id, org_id, org_id, start_time, end_time).Offset(offset).Limit(limit).Rows()
	if err != nil {
		fmt.Println(err)
	}
	defer rows.Close()

	// Define a map to hold the dynamic fields
	fields := map[string]interface{}{
		"dialysis_no":       "",
		"patient_name":      "",
		"dialysis_date":     "",
		"dialysis_duration": "",
		"actual_duration":   "",
		"diff":              0,
		"doctor":            "",
		"nurse":             "",
		"id_card_no":        "",
	}

	// Create the dynamic struct type
	dynamicStructType := createDynamicStruct(fields)

	// Slice to hold the results
	//var results []interface{}

	// Iterate over the rows and scan into the dynamic struct
	for rows.Next() {
		// Create a new instance of the dynamic struct
		result := reflect.New(dynamicStructType).Interface()

		// Create a slice of pointers to the fields in the struct
		fieldPtrs := []interface{}{
			reflect.ValueOf(result).Elem().FieldByName("Dialysis_no").Addr().Interface(),
			reflect.ValueOf(result).Elem().FieldByName("Patient_name").Addr().Interface(),
			reflect.ValueOf(result).Elem().FieldByName("Dialysis_date").Addr().Interface(),
			reflect.ValueOf(result).Elem().FieldByName("Dialysis_duration").Addr().Interface(),
			reflect.ValueOf(result).Elem().FieldByName("Actual_duration").Addr().Interface(),
			reflect.ValueOf(result).Elem().FieldByName("Diff").Addr().Interface(),
			reflect.ValueOf(result).Elem().FieldByName("Doctor").Addr().Interface(),
			reflect.ValueOf(result).Elem().FieldByName("Nurse").Addr().Interface(),
			reflect.ValueOf(result).Elem().FieldByName("Id_card_no").Addr().Interface(),
		}

		// Scan the row into the struct
		if err := rows.Scan(fieldPtrs...); err != nil {
			//log.Fatalf("failed to scan row: %v", err)
			fmt.Println(err)

		}

		// Append the result to the slice
		results = append(results, result)
	}

	return results, total, err
}

type QualityControlStandard struct {
	ItemName        string `json:"item_name"`
	ProjectMame     string `json:"project_name"`
	InspectionMajor int64  `json:"inspection_major"`
	InspectionMinor int64  `json:"inspection_minor"`
}

func getQualityControlStandards(org_id int64) ([]QualityControlStandard, error) {
	var standards []QualityControlStandard
	if err := readDb.Model(&models.XtQualityControlStandard{}).Select("re.project_name as project_name,re.item_name as item_name,xt_quality_control_standard.inspection_major as inspection_major,xt_quality_control_standard.inspection_minor as inspection_minor").Joins("join xt_inspection_reference re on re.project_id = xt_quality_control_standard.inspection_major and re.item_id = xt_quality_control_standard.inspection_minor and re.org_id = ?", org_id).Where("xt_quality_control_standard.user_org_id = ? and xt_quality_control_standard.status = 1", org_id).Scan(&standards).Error; err != nil {
		return nil, err
	}
	return standards, nil
}

type DialysisQualityStat struct {
	Month  string             `json:"月"`
	Name   string             `json:"姓名"`
	Counts map[string]float64 `json:"counts"`
}

//func GetLatestInspectionValues(org_id int64, yearMonth string) ([]map[string]interface{}, error) {
//	standards, err := getQualityControlStandards(org_id)
//	if err != nil {
//		return nil, err
//	}
//
//	var selectFields []string
//	for _, standard := range standards {
//		field := fmt.Sprintf("IFNULL(MAX(CASE WHEN i.item_name = %s THEN i.inspect_value END),'') AS `%s`",
//			"'"+standard.ItemName+"'", standard.ItemName)
//		selectFields = append(selectFields, field)
//	}
//
//	query := fmt.Sprintf(`
//		SELECT
//		    p.name as '姓名',
//			%s
//		FROM xt_inspection i
//		JOIN xt_patients p On p.id = i.patient_id
//		WHERE DATE_FORMAT(FROM_UNIXTIME(i.inspect_date), '%%Y-%%m') = ? and org_id = ?
//
//		GROUP BY i.patient_id
//	`, strings.Join(selectFields, ", "))
//
//	var results []map[string]interface{}
//	rows, err := readDb.Raw(query, yearMonth, org_id).Rows()
//	if err != nil {
//		return nil, err
//	}
//	defer rows.Close()
//
//	columns, err := rows.Columns()
//	if err != nil {
//		return nil, err
//	}
//
//	for rows.Next() {
//		// 创建一个长度为列数的切片，用于存储每一行的值
//		columnValues := make([]interface{}, len(columns))
//		columnPointers := make([]interface{}, len(columns))
//		for i := range columnValues {
//			columnPointers[i] = &columnValues[i]
//		}
//
//		// 扫描当前行的值
//		if err := rows.Scan(columnPointers...); err != nil {
//			return nil, err
//		}
//
//		// 将扫描到的值放入结果 map 中
//		result := make(map[string]interface{})
//		for i, colName := range columns {
//			val := columnPointers[i].(*interface{})
//			result[colName] = *val
//		}
//
//		results = append(results, result)
//	}
//
//	return results, nil
//}

func GetLatestInspectionValues(org_id int64, yearMonth string) ([]map[string]interface{}, error) {
	standards, err := getQualityControlStandards(org_id)
	if err != nil {
		return nil, err
	}

	var selectFields []string
	for _, standard := range standards {
		field := fmt.Sprintf("IFNULL(MAX(CASE WHEN latest_inspections.item_name = '%s' THEN latest_inspections.inspect_value END),'') AS `%s`",
			standard.ItemName, standard.ItemName)
		selectFields = append(selectFields, field)
	}

	query := fmt.Sprintf(`
			SELECT
			    p.name as '姓名',
				%s
			FROM xt_patients p
			JOIN (
				SELECT
					i1.patient_id,
					i1.item_name,
					i1.inspect_value
				FROM
					xt_inspection i1
				JOIN (
					SELECT
						patient_id,
						item_name,
						MAX(inspect_date) AS latest_inspect_date
					FROM
						xt_inspection
					WHERE
						DATE_FORMAT(FROM_UNIXTIME(inspect_date), '%%Y-%%m') = ?
						AND org_id = ?
					GROUP BY
						patient_id, item_name
				) latest
				ON
					i1.patient_id = latest.patient_id
					AND i1.item_name = latest.item_name
					AND i1.inspect_date = latest.latest_inspect_date
			) latest_inspections
			ON p.id = latest_inspections.patient_id 
			WHERE p.user_org_id = ? and p.lapseto = 1
			GROUP BY p.id, p.name
		`, strings.Join(selectFields, ", "))

	var results []map[string]interface{}
	rows, err := readDb.Raw(query, yearMonth, org_id, org_id).Rows() // 注意这里多传一个org_id参数
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	columns, err := rows.Columns()
	if err != nil {
		return nil, err
	}

	for rows.Next() {
		// 创建一个长度为列数的切片，用于存储每一行的值
		columnValues := make([]interface{}, len(columns))
		columnPointers := make([]interface{}, len(columns))
		for i := range columnValues {
			columnPointers[i] = &columnValues[i]
		}

		// 扫描当前行的值
		if err := rows.Scan(columnPointers...); err != nil {
			return nil, err
		}

		// 将扫描到的值放入结果 map 中
		result := make(map[string]interface{})
		for i, colName := range columns {
			val := columnPointers[i].(*interface{})
			result[colName] = *val
		}

		results = append(results, result)
	}

	return results, nil
}

//func GetLatestInspectionValues(org_id int64, yearMonth string) ([]map[string]interface{}, error) {
//	standards, err := getQualityControlStandards(org_id)
//	if err != nil {
//		return nil, err
//	}
//
//	var selectFields []string
//	for _, standard := range standards {
//		field := fmt.Sprintf("IFNULL(MAX(CASE WHEN latest_inspections.item_name = '%s' THEN latest_inspections.inspect_value END),'') AS `%s`",
//			standard.ItemName, standard.ItemName)
//		selectFields = append(selectFields, field)
//	}
//
//	query := fmt.Sprintf(`
//		SELECT
//		    p.name AS '姓名',
//			%s
//		FROM xt_patients p
//		LEFT JOIN (
//			SELECT
//				i1.patient_id,
//				i1.item_name,
//				i1.inspect_value
//			FROM
//				xt_inspection i1
//			JOIN (
//				SELECT
//					patient_id,
//					item_name,
//					MAX(inspect_date) AS latest_inspect_date
//				FROM
//					xt_inspection
//				WHERE
//					DATE_FORMAT(FROM_UNIXTIME(inspect_date), '%%Y-%%m') = ?
//					AND org_id = ?
//				GROUP BY
//					patient_id, item_name
//			) latest
//			ON
//				i1.patient_id = latest.patient_id
//				AND i1.item_name = latest.item_name
//				AND i1.inspect_date = latest.latest_inspect_date
//		) latest_inspections
//		ON p.id = latest_inspections.patient_id
//		WHERE p.user_org_id = ?
//		GROUP BY p.id, p.name
//	`, strings.Join(selectFields, ", "))
//
//	var results []map[string]interface{}
//	rows, err := readDb.Raw(query, yearMonth, org_id, org_id).Rows() // 注意这里多传一个org_id参数
//	if err != nil {
//		return nil, err
//	}
//	defer rows.Close()
//
//	columns, err := rows.Columns()
//	if err != nil {
//		return nil, err
//	}
//
//	for rows.Next() {
//		// 创建一个长度为列数的切片，用于存储每一行的值
//		columnValues := make([]interface{}, len(columns))
//		columnPointers := make([]interface{}, len(columns))
//		for i := range columnValues {
//			columnPointers[i] = &columnValues[i]
//		}
//
//		// 扫描当前行的值
//		if err := rows.Scan(columnPointers...); err != nil {
//			return nil, err
//		}
//
//		// 将扫描到的值放入结果 map 中
//		result := make(map[string]interface{})
//		for i, colName := range columns {
//			val := columnPointers[i].(*interface{})
//			result[colName] = *val
//		}
//
//		results = append(results, result)
//	}
//
//	return results, nil
//}

func createDynamicStruct(fields map[string]interface{}) reflect.Type {
	var structFields []reflect.StructField
	for name, value := range fields {
		structFields = append(structFields, reflect.StructField{
			Name: strings.Title(name),
			Type: reflect.TypeOf(value),
			Tag:  reflect.StructTag(fmt.Sprintf(`json:"%s"`, name)),
		})
	}
	return reflect.StructOf(structFields)
}

func GetDialysisPrescriptionInfo(start_date string, end_date string, mode int64, org_id int64, page int64, limit int64) (qcp []models.QCPrescription, total int64, err error) {
	offset := (page - 1) * limit

	err = readDb.Model(&models.QCPrescription{}).Preload("UserAdminRole", func(db *gorm.DB) *gorm.DB {
		return readUserDb.Where("status = 1 and org_id=?", org_id)
	}).Preload("QCPatients", "status = 1 and user_org_id = ?", org_id).Preload("QCDialysisOrder", func(db *gorm.DB) *gorm.DB {
		return db.Preload("UserAdminRole", func(db *gorm.DB) *gorm.DB {
			return readUserDb.Where("status = 1 and org_id=?", org_id)
		}).Preload("DeviceNumber", "status = 1 and org_id = ?", org_id).Where("status = 1 AND user_org_id = ?", org_id)
	}).Preload("QCAssessmentAfterDislysis", "status = 1 and user_org_id = ?", org_id).Where("FROM_UNIXTIME(record_date, '%Y-%m-%d') >= ? and FROM_UNIXTIME(record_date, '%Y-%m-%d') <= ? and user_org_id = ? and mode_id = ?  and status = 1", start_date, end_date, org_id, mode).Count(&total).Offset(offset).Limit(limit).Find(&qcp).Error
	return
}

func GetScheduleInfo(start_date string, end_date string, mode int64, org_id int64, page int64, limit int64) (qcp []models.QCSchedule, total int64, err error) {
	offset := (page - 1) * limit

	err = readDb.Model(&models.QCSchedule{}).Preload("QCPatients", "status = 1 and user_org_id =?", org_id).Preload("QCSPrescription", func(db *gorm.DB) *gorm.DB {
		return db.Preload("UserAdminRole", func(db *gorm.DB) *gorm.DB {
			return readUserDb.Where("status = 1 and org_id=?", org_id)
		}).Where("status = 1 AND user_org_id = ?", org_id)
	}).Preload("QCAssessmentAfterDislysis", "status = 1 and user_org_id = ?", org_id).Preload("QCDialysisOrder", func(db *gorm.DB) *gorm.DB {
		return db.Preload("DeviceNumber", "status = 1").Preload("UserAdminRole", func(db *gorm.DB) *gorm.DB {
			return readUserDb.Where("status = 1 and org_id=?", org_id)
		}).Where("status = 1 AND user_org_id = ?", org_id)
	}).Where("FROM_UNIXTIME(schedule_date, '%Y-%m-%d') >= ? and FROM_UNIXTIME(schedule_date, '%Y-%m-%d') <= ? and user_org_id = ? and mode_id = ? and status = 1", start_date, end_date, org_id, mode).Count(&total).Offset(offset).Limit(limit).Find(&qcp).Error
	return
}

type otherItemAmount struct {
	Total int64  `json:"total"`
	Name  string `json:"name"`
	Ratio string `json:"ratio"`
}

// xt_patients model
type Patient struct {
	ID       uint   `gorm:"primaryKey"`
	IDCardNo string `gorm:"column:id_card_no"`
}

func (Patient) TableName() string {
	return "xt_patients"
}

// xt_assessment_before_dislysis model
type Assessment struct {
	ID             uint    `gorm:"id"`
	PatientID      uint    `gorm:"column:patient_id"`
	SystolicBP     float64 `gorm:"column:systolic_blood_pressure"`
	DiastolicBP    float64 `gorm:"column:diastolic_blood_pressure"`
	AssessmentDate int64   `gorm:"column:assessment_date"`
	UserOrgID      int     `gorm:"column:user_org_id"`
}

func (Assessment) TableName() string {
	return "xt_assessment_before_dislysis"
}

// xt_assessment_before_dislysis model
type AssessmentAfter struct {
	ID             uint    `gorm:"id"`
	PatientID      uint    `gorm:"column:patient_id"`
	SystolicBP     float64 `gorm:"column:systolic_blood_pressure"`
	DiastolicBP    float64 `gorm:"column:diastolic_blood_pressure"`
	AssessmentDate int64   `gorm:"column:assessment_date"`
	UserOrgID      int     `gorm:"column:user_org_id"`
}

func (AssessmentAfter) TableName() string {
	return "xt_assessment_after_dislysis"
}

type WeightDetail struct {
	DialysisNo      string
	PatientName     string
	Gender          int64
	IDCardNo        string
	DialysisDate    string
	DryWeight       float64
	LastWeightAfter float64
	WeightBefore    float64
}

func GetNewDialysisWeightChartData(user_org_id int64, start_time int64, end_time int64, statistics_type int) (item []*otherItemAmount, err error) {
	//db := XTReadDB()
	var items []*otherItemAmount
	var tempErr error
	var Total int64
	switch statistics_type {
	case 1:

		newItemOne := &otherItemAmount{
			Total: 0,
			Name:  "小于40kg",
			Ratio: "0",
		}
		newItemTwo := &otherItemAmount{
			Total: 0,
			Name:  "40~50kg",
			Ratio: "0",
		}

		newItemThree := &otherItemAmount{
			Total: 0,
			Name:  "50~60kg",
			Ratio: "0",
		}

		newItemfour := &otherItemAmount{
			Total: 0,
			Name:  "60~70kg",
			Ratio: "0",
		}

		newItemfive := &otherItemAmount{
			Total: 0,
			Name:  "大于70kg",
			Ratio: "0",
		}

		newItemsix := &otherItemAmount{
			Total: 0,
			Name:  "未知",
			Ratio: "0",
		}

		data, total, _ := GetNewDialysisWeightDetailTableTenThree(user_org_id, start_time, end_time)
		Total = total
		for _, item := range data {
			fmt.Println(item.DryWeight < 40)
			if item.DryWeight < 40 {
				newItemOne.Total++

			} else if item.DryWeight >= 40 && item.DryWeight < 50 {
				newItemTwo.Total++

			} else if item.DryWeight >= 50 && item.DryWeight < 60 {

				newItemThree.Total++

			} else if item.DryWeight >= 60 && item.DryWeight < 70 {

				newItemfour.Total++

			} else if item.DryWeight >= 70 {

				newItemfive.Total++

				//isHasConditionFour = true
			} else {
				newItemsix.Total++

			}
		}
		items = append(items, newItemOne)
		items = append(items, newItemTwo)
		items = append(items, newItemThree)
		items = append(items, newItemfour)
		items = append(items, newItemfive)
		items = append(items, newItemsix)

		for _, item := range items {
			if math.IsNaN(float64(item.Total) / float64(Total)) {
				item.Ratio = "0.0"
			} else {
				float_value, _ := strconv.ParseFloat(fmt.Sprintf("%.1f", (float64(item.Total)/float64(Total))*100), 64)
				item.Ratio = strconv.FormatFloat(float_value, 'f', 1, 32)
			}
		}

		break

	case 2:
		var newTotal int64
		_, totalone, _ := GetNewDialysisWeightDetailTableTenTenOne(user_org_id, start_time, end_time, 1)
		_, totaltwo, _ := GetNewDialysisWeightDetailTableTenTenOne(user_org_id, start_time, end_time, 2)
		_, totalthree, _ := GetNewDialysisWeightDetailTableTenTenOne(user_org_id, start_time, end_time, 3)
		_, totalfour, _ := GetNewDialysisWeightDetailTableTenTenOne(user_org_id, start_time, end_time, 4)

		newTotal = totalone + totaltwo + totalthree + totalfour

		newItem := &otherItemAmount{
			Total: totalone,
			Name:  "体重增长<=3%",
			Ratio: "0",
		}
		newItem1 := &otherItemAmount{
			Total: totaltwo,
			Name:  "3%<体重增长<5%",
			Ratio: "0",
		}
		newItem2 := &otherItemAmount{
			Total: totalthree,
			Name:  "体重增长>=5%",
			Ratio: "0",
		}

		newItem3 := &otherItemAmount{
			Total: totalfour,
			Name:  "其他",
			Ratio: "0",
		}
		items = append(items, newItem)
		items = append(items, newItem1)
		items = append(items, newItem2)
		items = append(items, newItem3)

		for _, item := range items {
			if math.IsNaN(float64(item.Total) / float64(newTotal)) {
				item.Ratio = "0.0"
			} else {
				float_value, _ := strconv.ParseFloat(fmt.Sprintf("%.1f", (float64(item.Total)/float64(newTotal))*100), 64)
				item.Ratio = strconv.FormatFloat(float_value, 'f', 1, 32)
			}
		}

		break
	case 3:

		var newTotal int64
		_, totalone, _ := GetNewDialysisWeightDetailTableTenTenTwo(user_org_id, start_time, end_time, 1)
		_, totaltwo, _ := GetNewDialysisWeightDetailTableTenTenTwo(user_org_id, start_time, end_time, 2)
		_, totalthree, _ := GetNewDialysisWeightDetailTableTenTenTwo(user_org_id, start_time, end_time, 3)
		_, totalfour, _ := GetNewDialysisWeightDetailTableTenTenTwo(user_org_id, start_time, end_time, 4)

		newTotal = totalone + totaltwo + totalthree + totalfour

		newItem := &otherItemAmount{
			Total: totalone,
			Name:  "体重增长<=3%",
			Ratio: "0",
		}
		newItem1 := &otherItemAmount{
			Total: totaltwo,
			Name:  "3%<体重增长<5%",
			Ratio: "0",
		}
		newItem2 := &otherItemAmount{
			Total: totalthree,
			Name:  "体重增长>=5%",
			Ratio: "0",
		}

		newItem3 := &otherItemAmount{
			Total: totalfour,
			Name:  "其他",
			Ratio: "0",
		}
		items = append(items, newItem)
		items = append(items, newItem1)
		items = append(items, newItem2)
		items = append(items, newItem3)

		for _, item := range items {
			if math.IsNaN(float64(item.Total) / float64(newTotal)) {
				item.Ratio = "0.0"
			} else {
				float_value, _ := strconv.ParseFloat(fmt.Sprintf("%.1f", (float64(item.Total)/float64(newTotal))*100), 64)
				item.Ratio = strconv.FormatFloat(float_value, 'f', 1, 32)
			}
		}

		break
	case 4:
		var newTotal int64
		var total_one int64
		var total_two int64
		var total_three int64
		data, total, _ := GetNewDialysisWeightDetailTableTenTenOne(user_org_id, start_time, end_time, 0)
		newTotal = total
		for _, item := range data {
			if item.WeightStatus == "达标" {
				total_one++
			} else if item.WeightStatus == "不达标" {
				total_two++

			} else if item.WeightStatus == "其他" {
				total_three++
			}
		}

		newTotal = total_one + total_two + total_three

		newItem := &otherItemAmount{
			Total: total_one,
			Name:  "达到干体重",
			Ratio: "0",
		}
		newItem1 := &otherItemAmount{
			Total: total_two,
			Name:  "未达到干体重",
			Ratio: "0",
		}
		newItem2 := &otherItemAmount{
			Total: total_three,
			Name:  "其他或卧床",
			Ratio: "0",
		}

		items = append(items, newItem)
		items = append(items, newItem1)
		items = append(items, newItem2)
		for _, item := range items {
			if math.IsNaN(float64(item.Total) / float64(newTotal)) {
				item.Ratio = "0.0"
			} else {
				float_value, _ := strconv.ParseFloat(fmt.Sprintf("%.1f", (float64(item.Total)/float64(newTotal))*100), 64)
				item.Ratio = strconv.FormatFloat(float_value, 'f', 1, 32)
			}
		}

		break
	}
	if tempErr != nil {
		return nil, err
	}

	fmt.Println(items)
	return items, nil
}
func GetNewDialysisBloodChartData(user_org_id int64, start_time int64, end_time int64, statistics_type int) (item []otherItemAmount, err error) {
	db := XTReadDB()
	switch statistics_type {
	case 1:
		var assessments []Assessment
		err = db.Joins("JOIN xt_patients ON xt_patients.id = xt_assessment_before_dislysis.patient_id").
			Where("xt_assessment_before_dislysis.assessment_date >= ? AND xt_assessment_before_dislysis.assessment_date <= ? AND xt_assessment_before_dislysis.user_org_id = ?", start_time, end_time, user_org_id).
			Find(&assessments).Error
		if err != nil {
			log.Fatal("Query execution error:", err)
		}

		var total, metStandard, unmetStandard int

		// Iterate through the result set
		for _, assessment := range assessments {
			// Fetch patient information
			var patient Patient
			err = db.First(&patient, assessment.PatientID).Error
			if err != nil {
				log.Printf("Skipping record due to missing patient data for ID: %v", assessment.PatientID)
				continue
			}

			// Calculate the patient's age
			age, err := calculateAge(patient.IDCardNo)
			if err != nil {
				log.Printf("Skipping record due to invalid ID card number: %v", patient.IDCardNo)
				continue
			}

			// Update the total count of patients
			total++

			// Determine if the patient meets the standard based on their age and blood pressure
			if (age < 60 && assessment.SystolicBP < 140 && assessment.DiastolicBP < 90) || (age >= 60 && assessment.SystolicBP < 160 && assessment.DiastolicBP < 90) {
				metStandard++
			} else {
				unmetStandard++
			}
		}

		// Calculate and print the results
		if total > 0 {
			metPercentage := float64(metStandard) / float64(total) * 100
			unmetPercentage := float64(unmetStandard) / float64(total) * 100
			fmt.Printf("Total patients: %d\n", total)
			fmt.Printf("Met standard: %d (%.2f%%)\n", metStandard, metPercentage)
			fmt.Printf("Unmet standard: %d (%.2f%%)\n", unmetStandard, unmetPercentage)

			var items otherItemAmount
			items.Name = "达标患者"
			items.Ratio = strconv.FormatFloat(metPercentage, 'f', 1, 32)
			items.Total = int64(metStandard)
			item = append(item, items)

			var items2 otherItemAmount
			items2.Name = "未达标患者"
			items2.Ratio = strconv.FormatFloat(unmetPercentage, 'f', 1, 32)
			items2.Total = int64(unmetStandard)
			item = append(item, items2)

		}
	case 2:
		var assessments []AssessmentAfter
		err = db.Joins("JOIN xt_patients ON xt_patients.id = xt_assessment_after_dislysis.patient_id").
			Where("xt_assessment_after_dislysis.assessment_date >= ? AND xt_assessment_after_dislysis.assessment_date <= ? AND xt_assessment_after_dislysis.user_org_id = ?", start_time, end_time, user_org_id).
			Find(&assessments).Error
		if err != nil {
			log.Fatal("Query execution error:", err)
		}

		var total, metStandard, unmetStandard int

		// Iterate through the result set
		for _, assessment := range assessments {
			// Fetch patient information
			var patient Patient
			err = db.First(&patient, assessment.PatientID).Error
			if err != nil {
				log.Printf("Skipping record due to missing patient data for ID: %v", assessment.PatientID)
				continue
			}

			// Calculate the patient's age
			age, err := calculateAge(patient.IDCardNo)
			if err != nil {
				log.Printf("Skipping record due to invalid ID card number: %v", patient.IDCardNo)
				continue
			}

			// Update the total count of patients
			total++

			// Determine if the patient meets the standard based on their age and blood pressure
			if (age < 60 && assessment.SystolicBP < 140 && assessment.DiastolicBP < 90) || (age >= 60 && assessment.SystolicBP < 160 && assessment.DiastolicBP < 90) {
				metStandard++
			} else {
				unmetStandard++
			}
		}

		// Calculate and print the results
		if total > 0 {
			metPercentage := float64(metStandard) / float64(total) * 100
			unmetPercentage := float64(unmetStandard) / float64(total) * 100
			fmt.Printf("Total patients: %d\n", total)
			fmt.Printf("Met standard: %d (%.2f%%)\n", metStandard, metPercentage)
			fmt.Printf("Unmet standard: %d (%.2f%%)\n", unmetStandard, unmetPercentage)

			var items otherItemAmount
			items.Name = "达标患者"
			items.Ratio = strconv.FormatFloat(metPercentage, 'f', 1, 32)
			items.Total = int64(metStandard)
			item = append(item, items)

			var items2 otherItemAmount
			items2.Name = "未达标患者"
			items2.Ratio = strconv.FormatFloat(unmetPercentage, 'f', 1, 32)
			items2.Total = int64(unmetStandard)
			item = append(item, items2)
		}

		break
	}
	return
}
func calculateAge(idCardNo string) (int, error) {
	if len(idCardNo) < 14 {
		return 0, fmt.Errorf("invalid ID card number")
	}

	// Extract birth year, month, and day from ID card number
	year := idCardNo[6:10]
	month := idCardNo[10:12]
	day := idCardNo[12:14]

	// Parse the birth date
	birthDate, err := time.Parse("20060102", year+month+day)
	if err != nil {
		return 0, err
	}

	// Calculate age
	now := time.Now()
	age := now.Year() - birthDate.Year()
	if now.YearDay() < birthDate.YearDay() {
		age--
	}

	return age, nil
}

// 定义结果结构体
type DialysisDataTwo struct {
	DialysisNo        string  `json:"dialysis_no"`
	PatientName       string  `json:"patient_name"`
	Gender            string  `json:"gender"`
	Age               int     `json:"age"`
	AssessmentDate    string  `json:"assessment_date"` // 使用 string 存储日期，或使用 time.Time
	DryWeight         float64 `json:"dry_weight"`
	WeightBefore      float64 `json:"weight_before"`
	WeightAfter       float64 `json:"weight_after"`
	LastWeightAfter   float64 `json:"last_weight_after"` // 使用指针处理可能为空的值
	WeightAdd         float64 `json:"weight_add"`        // 使用指针处理可能为空的值
	DryWeightCategory string  `json:"dry_weight_category"`
	WeightStatus      string  `json:"weight_status"`
}

//	func GetNewDialysisWeightDetailTableTen(user_org_id int64, start_time int64, end_time int64, addType, dryType, afterType, page, limit int64) ([]DialysisDataTwo, int64, error) {
//		offset := (page - 1) * limit
//		var dialysisData []DialysisDataTwo
//		var total int64
//		// 构建基本查询
//		query := readDb.Table("xt_assessment_before_dislysis b").
//			Select(`
//				p.dialysis_no AS dialysis_no,
//				p.name AS patient_name,
//				p.gender AS gender,
//				FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
//				b.assessment_date AS assessment_date,
//				b.dry_weight AS dry_weight,
//				b.weight_before AS weight_before,
//				a.weight_after AS weight_after,
//				(
//					SELECT a2.weight_after
//					FROM xt_assessment_after_dislysis a2
//					JOIN xt_assessment_before_dislysis b2
//					ON a2.patient_id = b2.patient_id
//					AND a2.assessment_date = b2.assessment_date
//					WHERE b2.patient_id = b.patient_id
//					AND b2.assessment_date < b.assessment_date
//					ORDER BY b2.assessment_date DESC LIMIT 1
//				) AS last_weight_after,
//				CASE
//					WHEN (
//						SELECT a2.weight_after
//						FROM xt_assessment_after_dislysis a2
//						JOIN xt_assessment_before_dislysis b2
//						ON a2.patient_id = b2.patient_id
//						AND a2.assessment_date = b2.assessment_date
//						WHERE b2.patient_id = b.patient_id
//						AND b2.assessment_date < b.assessment_date
//						ORDER BY b2.assessment_date DESC LIMIT 1
//					) IS NOT NULL
//					THEN (b.weight_before - (
//						SELECT a2.weight_after
//						FROM xt_assessment_after_dislysis a2
//						JOIN xt_assessment_before_dislysis b2
//						ON a2.patient_id = b2.patient_id
//						AND a2.assessment_date = b2.assessment_date
//						WHERE b2.patient_id = b.patient_id
//						AND b2.assessment_date < b.assessment_date
//						ORDER BY b2.assessment_date DESC LIMIT 1
//					)) / (
//						SELECT a2.weight_after
//						FROM xt_assessment_after_dislysis a2
//						JOIN xt_assessment_before_dislysis b2
//						ON a2.patient_id = b2.patient_id
//						AND a2.assessment_date = b2.assessment_date
//						WHERE b2.patient_id = b.patient_id
//						AND b2.assessment_date < b.assessment_date
//						ORDER BY b2.assessment_date DESC LIMIT 1
//					)
//					ELSE NULL
//				END AS weight_add,
//				CASE
//					WHEN b.dry_weight IS NOT NULL THEN
//						CASE
//							WHEN b.dry_weight < 40 THEN '小于40'
//							WHEN b.dry_weight BETWEEN 40 AND 50 THEN '40～50'
//							WHEN b.dry_weight BETWEEN 50 AND 60 THEN '50～60'
//							WHEN b.dry_weight BETWEEN 60 AND 70 THEN '60～70'
//							WHEN b.dry_weight > 70 THEN '大于70'
//						END
//					ELSE '其他'
//				END AS dry_weight_category,
//				CASE
//					WHEN b.dry_weight IS NOT NULL THEN
//						CASE
//							WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
//							ELSE '不达标'
//						END
//					ELSE '其他'
//				END AS weight_status
//			`).
//			Joins("JOIN xt_patients p ON p.id = b.patient_id").
//			Joins("JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
//			Where("b.user_org_id = ?", user_org_id).
//			Where("b.assessment_date >= ?", start_time).
//			Where("b.assessment_date <= ?", end_time).
//			Where("b.status = ?", 1)
//
//		fmt.Println("dry_type")
//		fmt.Println(dryType)
//		switch dryType {
//		case 1:
//			query.Where("dry_weight_category = '小于40'")
//		case 2:
//			query.Where("dry_weight_category = '40～50'")
//		case 3:
//			query.Where("dry_weight_category = '50～60'")
//		case 4:
//			query.Where("dry_weight_category = '60～70'")
//		case 5:
//			query.Where("dry_weight_category = '大于70'")
//		}
//
//		// 根据传入的 add_type 值动态构建条件
//		addTypeCondition(query, addType)
//		// 根据传入的 dry_type 值动态构建条件
//		//fmt.Println("dry_type")
//		//fmt.Println(dryType)
//
//		//dryTypeCondition(query, dryType)
//		// 根据传入的 after_type 值动态构建条件
//		afterTypeCondition(query, afterType)
//		// 获取总记录数
//		if err := query.Count(&total).Error; err != nil {
//			return nil, 0, fmt.Errorf("count query failed: %v", err)
//		}
//		// 获取分页数据
//		rows, err := query.Order("p.id, b.assessment_date").Offset(int(offset)).Limit(int(limit)).Rows()
//		if err != nil {
//			return nil, 0, fmt.Errorf("pagination query failed: %v", err)
//		}
//		defer rows.Close()
//		// 处理结果集
//		for rows.Next() {
//			var data DialysisDataTwo
//			if err := rows.Scan(
//				&data.DialysisNo,
//				&data.PatientName,
//				&data.Gender,
//				&data.Age,
//				&data.AssessmentDate,
//				&data.DryWeight,
//				&data.WeightBefore,
//				&data.WeightAfter,
//				&data.LastWeightAfter,
//				&data.WeightAdd,
//				&data.DryWeightCategory,
//				&data.WeightStatus,
//			); err != nil {
//				return nil, 0, fmt.Errorf("row scan failed: %v", err)
//			}
//			// 将每一行结果追加到切片中
//			dialysisData = append(dialysisData, data)
//		}
//		return dialysisData, total, nil
//	}

func GetNewDialysisWeightDetailTableTenFour(
	user_org_id int64,
	start_time int64,
	end_time int64,
	addType, dryType, afterType, page, limit int64,
) ([]DialysisDataTwo, int64, error) {
	offset := (page - 1) * limit
	var total int64

	// 构建基本查询
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
          p.dialysis_no AS dialysis_no,
          p.name AS patient_name,
          p.gender AS gender,
          FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
          b.assessment_date AS assessment_date,
          b.dry_weight AS dry_weight,
          b.weight_before AS weight_before,
          a.weight_after AS weight_after,
          (
              SELECT a2.weight_after
              FROM xt_assessment_after_dislysis a2
              JOIN xt_assessment_before_dislysis b2
              ON a2.patient_id = b2.patient_id
              AND a2.assessment_date = b2.assessment_date
              WHERE b2.patient_id = b.patient_id
              AND b2.assessment_date < b.assessment_date
              ORDER BY b2.assessment_date DESC LIMIT 1
          ) AS last_weight_after,
          CASE
              WHEN (
                  SELECT a2.weight_after
                  FROM xt_assessment_after_dislysis a2
                  JOIN xt_assessment_before_dislysis b2
                  ON a2.patient_id = b2.patient_id
                  AND a2.assessment_date = b2.assessment_date
                  WHERE b2.patient_id = b.patient_id
                  AND b2.assessment_date < b.assessment_date
                  ORDER BY b2.assessment_date DESC LIMIT 1
              ) IS NOT NULL
              THEN (b.weight_before - (
                  SELECT a2.weight_after
                  FROM xt_assessment_after_dislysis a2
                  JOIN xt_assessment_before_dislysis b2
                  ON a2.patient_id = b2.patient_id
                  AND a2.assessment_date = b2.assessment_date
                  WHERE b2.patient_id = b.patient_id
                  AND b2.assessment_date < b.assessment_date
                  ORDER BY b2.assessment_date DESC LIMIT 1
              )) / (
                  SELECT a2.weight_after
                  FROM xt_assessment_after_dislysis a2
                  JOIN xt_assessment_before_dislysis b2
                  ON a2.patient_id = b2.patient_id
                  AND a2.assessment_date = b2.assessment_date
                  WHERE b2.patient_id = b.patient_id
                  AND b2.assessment_date < b.assessment_date
                  ORDER BY b2.assessment_date DESC LIMIT 1
              )
              ELSE NULL
          END AS weight_add,
          CASE
              WHEN b.dry_weight IS NOT NULL THEN
                  CASE
                      WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
                      ELSE '不达标'
                  END
              ELSE '其他'
          END AS weight_status
      `).
		Joins("left JOIN xt_patients p ON p.id = b.patient_id").
		Joins("left JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Where("b.status = ?", 1)

	// 处理干重过滤
	switch dryType {
	case 5:
		query = query.Where("b.dry_weight < ?", 40)
	case 1:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 40, 50)
	case 2:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 50, 60)
	case 3:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 60, 70)
	case 4:
		query = query.Where("b.dry_weight >= ?", 70)
	case 6:
		query = query.Where("b.dry_weight IS NULL OR b.dry_weight = ''")
	}

	// 处理加重过滤
	switch addType {
	case 1:
		query = query.Where("weight_add <= 0.03")
	case 2:
		query = query.Where("weight_add > 0.03 AND weight_add < 0.05")
	case 3:
		query = query.Where("weight_add >= 0.05")
	case 4:
		query = query.Where("weight_add IS NULL")
	}

	// 处理状态过滤
	switch afterType {
	case 1:
		query = query.Having("CASE WHEN b.dry_weight IS NOT NULL THEN CASE WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END ELSE '其他' END = ?", "达标")
	case 2:
		query = query.Having("CASE WHEN b.dry_weight IS NOT NULL THEN CASE WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END ELSE '其他' END = ?", "不达标")
	case 3:
		query = query.Having("CASE WHEN b.dry_weight IS NOT NULL THEN CASE WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END ELSE '其他' END = ?", "其他")
	}

	// 获取总记录数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}

	var data []DialysisDataTwo
	query.Order("p.id, b.assessment_date").Offset(int(offset)).Limit(int(limit)).Find(&data)
	fmt.Println(data)
	return data, total, nil
}

// func GetNewDialysisWeightDetailTableTen(
//
//		user_org_id int64,
//		start_time int64,
//		end_time int64,
//		addType, dryType, afterType, page, limit int64, keyword string) ([]DialysisDataTwo, int64, error) {
//		offset := (page - 1) * limit
//		//var dialysisData []DialysisDataTwo
//		var total int64
//		keyword = "%" + keyword + "%"
//		// 构建基本查询
//		query := readDb.Table("xt_assessment_before_dislysis b").
//			Select(`
//	         p.dialysis_no AS dialysis_no,
//	         p.name AS patient_name,
//	         p.gender AS gender,
//	         FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
//	         b.assessment_date AS assessment_date,
//	         latest_dry_weight.dry_weight AS dry_weight,
//	         b.dry_weight AS dry_weight,
//	         b.weight_before AS weight_before,
//	         a.weight_after AS weight_after,
//	         (
//	             SELECT a2.weight_after
//	             FROM xt_assessment_after_dislysis a2
//	             JOIN xt_assessment_before_dislysis b2
//	             ON a2.patient_id = b2.patient_id
//	             AND a2.assessment_date = b2.assessment_date
//	             WHERE b2.patient_id = b.patient_id
//	             AND b2.assessment_date < b.assessment_date
//	             ORDER BY b2.assessment_date DESC LIMIT 1
//	         ) AS last_weight_after,
//	         CASE
//	             WHEN (
//	                 SELECT a2.weight_after
//	                 FROM xt_assessment_after_dislysis a2
//	                 JOIN xt_assessment_before_dislysis b2
//	                 ON a2.patient_id = b2.patient_id
//	                 AND a2.assessment_date = b2.assessment_date
//	                 WHERE b2.patient_id = b.patient_id
//	                 AND b2.assessment_date < b.assessment_date
//	                 ORDER BY b2.assessment_date DESC LIMIT 1
//	             ) IS NOT NULL
//	             THEN (b.weight_before - (
//	                 SELECT a2.weight_after
//	                 FROM xt_assessment_after_dislysis a2
//	                 JOIN xt_assessment_before_dislysis b2
//	                 ON a2.patient_id = b2.patient_id
//	                 AND a2.assessment_date = b2.assessment_date
//	                 WHERE b2.patient_id = b.patient_id
//	                 AND b2.assessment_date < b.assessment_date
//	                 ORDER BY b2.assessment_date DESC LIMIT 1
//	             )) / (
//	                 SELECT a2.weight_after
//	                 FROM xt_assessment_after_dislysis a2
//	                 JOIN xt_assessment_before_dislysis b2
//	                 ON a2.patient_id = b2.patient_id
//	                 AND a2.assessment_date = b2.assessment_date
//	                 WHERE b2.patient_id = b.patient_id
//	                 AND b2.assessment_date < b.assessment_date
//	                 ORDER BY b2.assessment_date DESC LIMIT 1
//	             )
//	             ELSE NULL
//	         END AS weight_add,
//	         CASE
//	            WHEN a.weight_after IS NULL THEN '其他'
//	             WHEN b.dry_weight IS NOT NULL THEN
//	                 CASE
//	                     WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
//	                     ELSE '不达标'
//	                 END
//	             ELSE '其他'
//	         END AS weight_status
//	     `).
//			Joins("JOIN xt_patients p ON p.id = b.patient_id and p.name like ?", keyword).
//			Joins("left JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
//			Where("b.user_org_id = ?", user_org_id).
//			Where("b.assessment_date >= ?", start_time).
//			Where("b.assessment_date <= ?", end_time).
//			Where("b.status = ?", 1)
//
//		switch dryType {
//		case 5:
//			query = query.Where("b.dry_weight < ?", 40)
//		case 1:
//			query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 40, 50)
//		case 2:
//			query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 50, 60)
//		case 3:
//			query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 60, 70)
//		case 4:
//			query = query.Where("b.dry_weight >= ?", 70)
//		case 6:
//			query = query.Where("b.dry_weight IS NULL OR b.dry_weight = ''")
//		}
//
//		switch addType {
//		case 1:
//			query = query.Where(`
//	      (
//	          CASE
//	              WHEN (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              ) IS NOT NULL
//	              THEN (b.weight_before - (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              )) / (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              )
//	              ELSE NULL
//	          END
//	      ) <= 0.03
//	  `)
//		case 2:
//			query = query.Where(`
//	      (
//	          CASE
//	              WHEN (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              ) IS NOT NULL
//	              THEN (b.weight_before - (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              )) / (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              )
//	              ELSE NULL
//	          END
//	      ) > 0.03 AND (
//	          CASE
//	              WHEN (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              ) IS NOT NULL
//	              THEN (b.weight_before - (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              )) / (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              )
//	              ELSE NULL
//	          END
//	      ) < 0.05
//	  `)
//		case 3:
//			query = query.Where(`
//	      (
//	          CASE
//	              WHEN (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              ) IS NOT NULL
//	              THEN (b.weight_before - (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              )) / (
//	                  SELECT a2.weight_after
//	                  FROM xt_assessment_after_dislysis a2
//	                  JOIN xt_assessment_before_dislysis b2
//	                  ON a2.patient_id = b2.patient_id
//	                  AND a2.assessment_date = b2.assessment_date
//	                  WHERE b2.patient_id = b.patient_id
//	                  AND b2.assessment_date < b.assessment_date
//	                  ORDER BY b2.assessment_date DESC LIMIT 1
//	              )
//	              ELSE NULL
//	          END
//	      ) >= 0.05
//	  `)
//		case 4:
//			query = query.Where(`
//	      (
//	          SELECT a2.weight_after
//	          FROM xt_assessment_after_dislysis a2
//	          JOIN xt_assessment_before_dislysis b2
//	          ON a2.patient_id = b2.patient_id
//	          AND a2.assessment_date = b2.assessment_date
//	          WHERE b2.patient_id = b.patient_id
//	          AND b2.assessment_date < b.assessment_date
//	          ORDER BY b2.assessment_date DESC LIMIT 1
//	      ) IS NULL
//	  `)
//		}
//
//		switch afterType {
//		case 1:
//			query = query.Where(`
//	      CASE
//	          WHEN a.weight_after IS NULL THEN '其他'
//	          WHEN b.dry_weight IS NOT NULL THEN
//	              CASE
//	                  WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
//	                  ELSE '不达标'
//	              END
//	          ELSE '其他'
//	      END = ?`, "达标")
//		case 2:
//			query = query.Where(`
//	      CASE
//	          WHEN a.weight_after IS NULL THEN '其他'
//	          WHEN b.dry_weight IS NOT NULL THEN
//	              CASE
//	                  WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
//	                  ELSE '不达标'
//	              END
//	          ELSE '其他'
//	      END = ?`, "不达标")
//		case 3:
//			query = query.Where(`
//	      CASE
//	          WHEN a.weight_after IS NULL THEN '其他'
//	          WHEN b.dry_weight IS NOT NULL THEN
//	              CASE
//	                  WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
//	                  ELSE '不达标'
//	              END
//	          ELSE '其他'
//	      END = ?`, "其他")
//		}
//
//		//// 获取总记录数
//		if err := query.Count(&total).Error; err != nil {
//			return nil, 0, fmt.Errorf("count query failed: %v", err)
//		}
//
//		var data []DialysisDataTwo
//
//		query.Order("p.id, b.assessment_date").Offset(int(offset)).Limit(int(limit)).Find(&data)
//
//		return data, total, nil
//	}
//func GetNewDialysisWeightDetailTableTenTenOne(
//	user_org_id int64,
//	start_time int64,
//	end_time int64,
//
//) ([]DialysisDataTwo, int64, error) {
//
//	// Build base query
//	query := readDb.Table("xt_assessment_before_dislysis b").
//		Select(`
//		         p.dialysis_no AS dialysis_no,
//		         p.name AS patient_name,
//		         p.gender AS gender,
//		         FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
//		         b.assessment_date AS assessment_date,
//		         b.dry_weight AS dry_weight,
//		         b.weight_before AS weight_before,
//		         a.weight_after AS weight_after,
//		         (
//		             SELECT a2.weight_after
//		             FROM xt_assessment_after_dislysis a2
//		             WHERE a2.patient_id = b.patient_id
//		             AND a2.assessment_date < b.assessment_date
//		             ORDER BY a2.assessment_date DESC LIMIT 1
//		         ) AS last_weight_after,
//		         CASE
//		             WHEN (
//		                 SELECT a2.weight_after
//		                 FROM xt_assessment_after_dislysis a2
//		                 WHERE a2.patient_id = b.patient_id
//		                 AND a2.assessment_date < b.assessment_date
//		                 ORDER BY a2.assessment_date DESC LIMIT 1
//		             ) IS NOT NULL
//		             THEN (b.weight_before - (
//		                 SELECT a2.weight_after
//		                 FROM xt_assessment_after_dislysis a2
//		                 WHERE a2.patient_id = b.patient_id
//		                 AND a2.assessment_date < b.assessment_date
//		                 ORDER BY a2.assessment_date DESC LIMIT 1
//		             )) / (
//		                 SELECT a2.weight_after
//		                 FROM xt_assessment_after_dislysis a2
//		                 WHERE a2.patient_id = b.patient_id
//		                 AND a2.assessment_date < b.assessment_date
//		                 ORDER BY a2.assessment_date DESC LIMIT 1
//		             )
//		             ELSE NULL
//		         END AS weight_add,
//		         CASE
//		            WHEN a.weight_after IS NULL OR a.weight_after = 0 THEN '其他'
//		            WHEN latest_dry_weight.dry_weight IS NOT NULL THEN
//		                CASE
//		                    WHEN ABS(a.weight_after - latest_dry_weight.dry_weight) <= 0.3 THEN '达标'
//		                    ELSE '不达标'
//		                END
//		            ELSE '其他'
//		         END AS weight_status
//		     `).
//		Joins("JOIN xt_patients p ON p.id = b.patient_id ").
//		Joins("LEFT JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
//		Where("b.user_org_id = ?", user_org_id).
//		Where("b.assessment_date BETWEEN ? AND ?", start_time, end_time).
//		Where("b.assessment_date = latest_dry_weight.max_assessment_date").
//		Where("b.status = ?", 1)
//
//	// Apply filters for dryType
//
//	// Apply filters for addType
//
//	// Apply filters for afterType
//	var total int64
//
//	// Count total records
//	if err := query.Count(&total).Error; err != nil {
//		return nil, 0, fmt.Errorf("count query failed: %v", err)
//	}
//
//	// Fetch data with pagination
//	var data []DialysisDataTwo
//	if err := query.Order("p.id, b.assessment_date").Find(&data).Error; err != nil {
//		return nil, 0, fmt.Errorf("data query failed: %v", err)
//	}
//
//	return data, total, nil
//}

// func GetNewDialysisWeightDetailTableTenTenOne(
//
//	user_org_id int64,
//	start_time int64,
//	end_time int64,
//	addType, dryType, afterType, page, limit int64, keyword string,
//
//	) ([]DialysisDataTwo, int64, error) {
//		offset := (page - 1) * limit
//		var total int64
//		keyword = "%" + keyword + "%"
//
//		// Build base query
//		query := readDb.Table("xt_assessment_before_dislysis b").
//			Select(`
//		         p.dialysis_no AS dialysis_no,
//		         p.name AS patient_name,
//		         p.gender AS gender,
//		         FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
//		         b.assessment_date AS assessment_date,
//		         latest_dry_weight.dry_weight AS dry_weight,
//		         b.weight_before AS weight_before,
//		         a.weight_after AS weight_after,
//		         (
//		             SELECT a2.weight_after
//		             FROM xt_assessment_after_dislysis a2
//		             WHERE a2.patient_id = b.patient_id
//		             AND a2.assessment_date < b.assessment_date
//		             ORDER BY a2.assessment_date DESC LIMIT 1
//		         ) AS last_weight_after,
//		         CASE
//		             WHEN (
//		                 SELECT a2.weight_after
//		                 FROM xt_assessment_after_dislysis a2
//		                 WHERE a2.patient_id = b.patient_id
//		                 AND a2.assessment_date < b.assessment_date
//		                 ORDER BY a2.assessment_date DESC LIMIT 1
//		             ) IS NOT NULL
//		             THEN (b.weight_before - (
//		                 SELECT a2.weight_after
//		                 FROM xt_assessment_after_dislysis a2
//		                 WHERE a2.patient_id = b.patient_id
//		                 AND a2.assessment_date < b.assessment_date
//		                 ORDER BY a2.assessment_date DESC LIMIT 1
//		             )) / (
//		                 SELECT a2.weight_after
//		                 FROM xt_assessment_after_dislysis a2
//		                 WHERE a2.patient_id = b.patient_id
//		                 AND a2.assessment_date < b.assessment_date
//		                 ORDER BY a2.assessment_date DESC LIMIT 1
//		             )
//		             ELSE NULL
//		         END AS weight_add,
//		         CASE
//		            WHEN a.weight_after IS NULL THEN '其他'
//		            WHEN latest_dry_weight.dry_weight IS NOT NULL THEN
//		                CASE
//		                    WHEN ABS(a.weight_after - latest_dry_weight.dry_weight) <= 0.3 THEN '达标'
//		                    ELSE '不达标'
//		                END
//		            ELSE '其他'
//		         END AS weight_status
//		     `).
//			Joins("JOIN xt_patients p ON p.id = b.patient_id AND p.name LIKE ?", keyword).
//			Joins("LEFT JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
//			Joins("JOIN (SELECT b2.patient_id, MAX(b2.assessment_date) AS max_assessment_date, MAX(b2.dry_weight) AS dry_weight FROM xt_assessment_before_dislysis b2 WHERE b2.user_org_id = ? AND b2.assessment_date BETWEEN ? AND ? GROUP BY b2.patient_id) latest_dry_weight ON latest_dry_weight.patient_id = b.patient_id", user_org_id, start_time, end_time).
//			Where("b.user_org_id = ?", user_org_id).
//			Where("b.assessment_date BETWEEN ? AND ?", start_time, end_time).
//			Where("b.assessment_date = latest_dry_weight.max_assessment_date").
//			Where("b.status = ?", 1)
//
//		// Apply filters for dryType
//		switch dryType {
//		case 5:
//			query = query.Where("b.dry_weight < ?", 40)
//		case 1:
//			query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 40, 50)
//		case 2:
//			query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 50, 60)
//		case 3:
//			query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 60, 70)
//		case 4:
//			query = query.Where("b.dry_weight >= ?", 70)
//		case 6:
//			query = query.Where("b.dry_weight IS NULL OR b.dry_weight = ''")
//		}
//
//		// Apply filters for addType
//		switch addType {
//		case 1:
//			query = query.Where("(b.weight_before - last_weight_after) / last_weight_after <= 0.03")
//		case 2:
//			query = query.Where("(b.weight_before - last_weight_after) / last_weight_after > 0.03 AND (b.weight_before - last_weight_after) / last_weight_after < 0.05")
//		case 3:
//			query = query.Where("(b.weight_before - last_weight_after) / last_weight_after >= 0.05")
//		case 4:
//			query = query.Where("last_weight_after IS NULL")
//		}
//
//		// Apply filters for afterType
//		switch afterType {
//		case 1:
//			query = query.Where("CASE WHEN a.weight_after IS NULL THEN '其他' WHEN latest_dry_weight.dry_weight IS NOT NULL AND ABS(a.weight_after - latest_dry_weight.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END = ?", "达标")
//		case 2:
//			query = query.Where("CASE WHEN a.weight_after IS NULL THEN '其他' WHEN latest_dry_weight.dry_weight IS NOT NULL AND ABS(a.weight_after - latest_dry_weight.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END = ?", "不达标")
//		case 3:
//			query = query.Where("CASE WHEN a.weight_after IS NULL THEN '其他' WHEN latest_dry_weight.dry_weight IS NOT NULL AND ABS(a.weight_after - latest_dry_weight.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END = ?", "其他")
//		}
//
//		// Count total records
//		if err := query.Count(&total).Error; err != nil {
//			return nil, 0, fmt.Errorf("count query failed: %v", err)
//		}
//
//		// Fetch data with pagination
//		var data []DialysisDataTwo
//		if err := query.Order("p.id, b.assessment_date").Offset(int(offset)).Limit(int(limit)).Find(&data).Error; err != nil {
//			return nil, 0, fmt.Errorf("data query failed: %v", err)
//		}
//
//		return data, total, nil
//	}
func GetNewDialysisWeightDetailTableTen(
	user_org_id int64,
	start_time int64,
	end_time int64,
	addType, dryType, afterType, page, limit int64, keyword string,
) ([]DialysisDataTwo, int64, error) {
	offset := (page - 1) * limit
	var total int64
	keyword = "%" + keyword + "%"

	// Build base query
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
			p.dialysis_no AS dialysis_no,
			p.name AS patient_name,
			p.gender AS gender,
			FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
			b.assessment_date AS assessment_date,
			latest_dry_weight.dry_weight AS dry_weight,
			b.weight_before AS weight_before,
			a.weight_after AS weight_after,
			(
				SELECT a2.weight_after
				FROM xt_assessment_after_dislysis a2
				WHERE a2.patient_id = b.patient_id
				AND a2.assessment_date < b.assessment_date
				ORDER BY a2.assessment_date DESC LIMIT 1
			) AS last_weight_after
		`).
		Joins("JOIN xt_patients p ON p.id = b.patient_id AND p.name LIKE ?", keyword).
		Joins("LEFT JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
		Joins("JOIN (SELECT b2.patient_id, MAX(b2.assessment_date) AS max_assessment_date, MAX(b2.dry_weight) AS dry_weight FROM xt_assessment_before_dislysis b2 WHERE b2.user_org_id = ? AND b2.assessment_date BETWEEN ? AND ? GROUP BY b2.patient_id) latest_dry_weight ON latest_dry_weight.patient_id = b.patient_id", user_org_id, start_time, end_time).
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date BETWEEN ? AND ?", start_time, end_time).
		Where("b.assessment_date = latest_dry_weight.max_assessment_date").
		Where("b.status = ?", 1)

	// Apply filters for dryType
	switch dryType {
	case 5:
		query = query.Where("b.dry_weight < ?", 40)
	case 1:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 40, 50)
	case 2:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 50, 60)
	case 3:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 60, 70)
	case 4:
		query = query.Where("b.dry_weight >= ?", 70)
	case 6:
		query = query.Where("b.dry_weight IS NULL OR b.dry_weight = ''")
	}

	// Calculate last_weight_after as a subquery in the HAVING clause
	query = query.Having("last_weight_after IS NOT NULL")

	// Apply filters for addType
	switch addType {
	case 1:
		query = query.Having("(b.weight_before - last_weight_after) / last_weight_after <= 0.03")
	case 2:
		query = query.Having("(b.weight_before - last_weight_after) / last_weight_after > 0.03 AND (b.weight_before - last_weight_after) / last_weight_after < 0.05")
	case 3:
		query = query.Having("(b.weight_before - last_weight_after) / last_weight_after >= 0.05")
	case 4:
		query = query.Having("last_weight_after IS NULL")
	}

	// Apply filters for afterType
	switch afterType {
	case 1:
		query = query.Where("CASE WHEN a.weight_after IS NULL or  a.weight_after = 0 THEN '其他' WHEN latest_dry_weight.dry_weight IS NOT NULL AND ABS(a.weight_after - latest_dry_weight.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END = ?", "达标")
	case 2:
		query = query.Where("CASE WHEN a.weight_after IS NULL or a.weight_after = 0 THEN '其他' WHEN latest_dry_weight.dry_weight IS NOT NULL AND ABS(a.weight_after - latest_dry_weight.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END = ?", "不达标")
	case 3:
		query = query.Where("CASE WHEN a.weight_after IS NULL or a.weight_after = 0 THEN '其他' WHEN latest_dry_weight.dry_weight IS NOT NULL AND ABS(a.weight_after - latest_dry_weight.dry_weight) <= 0.3 THEN '达标' ELSE '不达标' END = ?", "其他")
	}

	var data2 []DialysisDataTwo
	//// Count total records
	if err := query.Find(&data2).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}
	total = int64(len(data2))
	// Fetch data with pagination
	var data []DialysisDataTwo
	if err := query.Order("p.id, b.assessment_date").Offset(int(offset)).Limit(int(limit)).Find(&data).Error; err != nil {
		return nil, 0, fmt.Errorf("data query failed: %v", err)
	}

	return data, total, nil
}

func GetNewDialysisWeightDetailTableTenTen(
	user_org_id int64,
	start_time int64,
	end_time int64) ([]DialysisDataTwo, int64, error) {

	// Build base query
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
			p.dialysis_no AS dialysis_no,
			p.name AS patient_name,
			p.gender AS gender,
			FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
			b.assessment_date AS assessment_date,
			latest_dry_weight.dry_weight AS dry_weight,
			b.weight_before AS weight_before,
			a.weight_after AS weight_after,
			(
				SELECT a2.weight_after
				FROM xt_assessment_after_dislysis a2
				WHERE a2.patient_id = b.patient_id
				AND a2.assessment_date < b.assessment_date
				ORDER BY a2.assessment_date DESC LIMIT 1
			) AS last_weight_after
		`).
		Joins("JOIN xt_patients p ON p.id = b.patient_id").
		Joins("LEFT JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
		Joins("JOIN (SELECT b2.patient_id, MAX(b2.assessment_date) AS max_assessment_date, MAX(b2.dry_weight) AS dry_weight FROM xt_assessment_before_dislysis b2 WHERE b2.user_org_id = ? AND b2.assessment_date BETWEEN ? AND ? GROUP BY b2.patient_id) latest_dry_weight ON latest_dry_weight.patient_id = b.patient_id", user_org_id, start_time, end_time).
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date BETWEEN ? AND ?", start_time, end_time).
		Where("b.assessment_date = latest_dry_weight.max_assessment_date").
		Where("b.status = ?", 1)

	// Calculate last_weight_after as a subquery in the HAVING clause
	//query = query.Having("last_weight_after IS NOT NULL")

	//var data2 []DialysisDataTwo
	//Count total records
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}

	//total = int64(len(data2))
	// Fetch data with pagination
	var data []DialysisDataTwo
	if err := query.Order("p.id, b.assessment_date").Find(&data).Error; err != nil {
		return nil, 0, fmt.Errorf("data query failed: %v", err)
	}

	return data, total, nil
}

func GetNewDialysisWeightDetailTableTenThree(
	user_org_id int64,
	start_time int64,
	end_time int64,
) ([]DialysisDataTwo, int64, error) {

	// Subquery to get the latest assessment date for each patient
	subQuery := `
		SELECT MAX(ctime) AS max_ctime, patient_id
		FROM xt_patient_dryweight
		WHERE user_org_id = ? AND ctime BETWEEN ? AND ? AND status = 1
		GROUP BY patient_id
	`

	// Build main query to get the latest records for each patient
	query := readDb.Table("xt_patient_dryweight b").
		Select(`
          p.dialysis_no AS dialysis_no,
          p.name AS patient_name,
          FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
          b.dry_weight AS dry_weight
      `).
		Joins("JOIN xt_patients p ON p.id = b.patient_id").
		Joins("JOIN ("+subQuery+") AS latest ON b.patient_id = latest.patient_id AND b.ctime = latest.max_ctime", user_org_id, start_time, end_time).
		Where("b.user_org_id = ?", user_org_id).
		Where("b.ctime BETWEEN ? AND ?", start_time, end_time)

	// Fetch data with pagination
	var data []DialysisDataTwo
	if err := query.Order("p.id").Find(&data).Error; err != nil {
		return nil, 0, fmt.Errorf("data query failed: %v", err)
	}

	return data, int64(len(data)), nil
}

func GetNewDialysisWeightDetailTableTenSix(
	user_org_id int64,
	start_time int64,
	end_time int64, dryType int64, page, limit int64) ([]DialysisDataTwo, int64, error) {
	offset := (page - 1) * limit
	var total int64
	// Subquery to get the latest assessment date for each patient
	subQuery := `
		SELECT MAX(ctime) AS max_ctime, patient_id
		FROM xt_patient_dryweight
		WHERE user_org_id = ? AND ctime BETWEEN ? AND ? AND status = 1
		GROUP BY patient_id
	`
	// Build main query to get the latest records for each patient
	query := readDb.Table("xt_patient_dryweight b").
		Select(`
          p.dialysis_no AS dialysis_no,
          p.name AS patient_name,
          FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
          b.dry_weight AS dry_weight
      `).
		Joins("JOIN xt_patients p ON p.id = b.patient_id").
		Joins("JOIN ("+subQuery+") AS latest ON b.patient_id = latest.patient_id AND b.ctime = latest.max_ctime", user_org_id, start_time, end_time).
		Where("b.user_org_id = ?", user_org_id).
		Where("b.ctime BETWEEN ? AND ?", start_time, end_time)

	switch dryType {
	case 5:
		query = query.Where("b.dry_weight < ?", 40)
	case 1:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 40, 50)
	case 2:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 50, 60)
	case 3:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 60, 70)
	case 4:
		query = query.Where("b.dry_weight >= ?", 70)
	case 6:
		query = query.Where("b.dry_weight IS NULL OR b.dry_weight = ''")
	}
	// Fetch data with pagination
	var data []DialysisDataTwo
	if err := query.Order("p.id").Offset(int(offset)).Limit(int(limit)).Find(&data).Error; err != nil {
		return nil, 0, fmt.Errorf("data query failed: %v", err)
	}

	var data2 []DialysisDataTwo
	if err := query.Find(&data2).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}
	total = int64(len(data2))
	// Fetch data with pagination

	return data, total, nil
}

//func GetNewDialysisWeightDetailTableTenThree(
//	user_org_id int64,
//	start_time int64,
//	end_time int64,
//) ([]DialysisDataTwo, int64, error) {
//	var total int64
//	// Build base query
//	query := readDb.Table("xt_patient_dryweight b").
//		Select(`
//          p.dialysis_no AS dialysis_no,
//          p.name AS patient_name,
//          FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
//          b.dry_weight AS dry_weight,
//      `).
//		Joins("JOIN xt_patients p ON p.id = b.patient_id").
//		Where("b.user_org_id = ?", user_org_id).
//		Where("b.ctime BETWEEN ? AND ?", start_time, end_time).
//		Where("b.status = ?", 1)
//
//	// Count total records
//	if err := query.Count(&total).Error; err != nil {
//		return nil, 0, fmt.Errorf("count query failed: %v", err)
//	}
//
//	// Fetch data with pagination
//	var data []DialysisDataTwo
//	if err := query.Order("p.id, b.assessment_date").Find(&data).Error; err != nil {
//		return nil, 0, fmt.Errorf("data query failed: %v", err)
//	}
//
//	return data, total, nil
//}

func GetNewDialysisWeightDetailTableTenOne(
	user_org_id int64,
	start_time int64,
	end_time int64) ([]DialysisDataTwo, error) {
	// 构建基本查询
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
           CASE
               WHEN (
                   SELECT a2.weight_after
                   FROM xt_assessment_after_dislysis a2
                   JOIN xt_assessment_before_dislysis b2
                   ON a2.patient_id = b2.patient_id
                   AND a2.assessment_date = b2.assessment_date
                   WHERE b2.patient_id = b.patient_id
                   AND b2.assessment_date < b.assessment_date
                   ORDER BY b2.assessment_date DESC LIMIT 1
               ) IS NOT NULL
               THEN (b.weight_before - (
                   SELECT a2.weight_after
                   FROM xt_assessment_after_dislysis a2
                   JOIN xt_assessment_before_dislysis b2
                   ON a2.patient_id = b2.patient_id
                   AND a2.assessment_date = b2.assessment_date
                   WHERE b2.patient_id = b.patient_id
                   AND b2.assessment_date < b.assessment_date
                   ORDER BY b2.assessment_date DESC LIMIT 1
               )) / (
                   SELECT a2.weight_after
                   FROM xt_assessment_after_dislysis a2
                   JOIN xt_assessment_before_dislysis b2
                   ON a2.patient_id = b2.patient_id
                   AND a2.assessment_date = b2.assessment_date
                   WHERE b2.patient_id = b.patient_id
                   AND b2.assessment_date < b.assessment_date
                   ORDER BY b2.assessment_date DESC LIMIT 1
               )
               ELSE NULL
           END AS weight_add

       `).
		Joins("left JOIN xt_patients p ON p.id = b.patient_id").
		Joins("left JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Where("b.status = ?", 1)

	var data []DialysisDataTwo
	query.Order("p.id, b.assessment_date").Find(&data)

	return data, nil
}

func GetNewDialysisWeightDetailTableTenTwo(
	user_org_id int64,
	start_time int64,
	end_time int64) ([]DialysisDataTwo, error) {

	// Construct the base query
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
           (b.weight_before - b.dry_weight) / b.dry_weight * 100 AS weight_add
       `).
		Joins("left JOIN xt_patients p ON p.id = b.patient_id").
		Joins("left JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Where("b.status = ?", 1)

	var data []DialysisDataTwo
	query.Order("p.id, b.assessment_date").Find(&data)

	return data, nil
}

// addType 条件处理
func addTypeCondition(query *gorm.DB, addType int64) {

}

// dryType 条件处理
func dryTypeCondition(query *gorm.DB, dryType int64) {

}

// afterType 条件处理
func afterTypeCondition(query *gorm.DB, afterType int64) {
	switch afterType {
	case 1:
		query = query.Where("weight_status = '达标'")
	case 2:
		query = query.Where("weight_status = '不达标'")
	case 3:
		query = query.Where("weight_status = '其他'")
	}
}

type DialysisDataThree struct {
	DialysisNo            string  `json:"dialysis_no"`
	PatientName           string  `json:"patient_name"`
	Gender                string  `json:"gender"`
	Age                   int     `json:"age"`
	AssessmentDate        string  `json:"assessment_date"`
	DryWeight             float64 `json:"dry_weight"`
	PreDialysisBP         string  `json:"pre_dialysis_bp"`
	PostDialysisBP        string  `json:"post_dialysis_bp"`
	MonitoringBP          string  `json:"monitoring_bp"`
	UltrafiltrationRate   float64 `json:"ultrafiltration_rate"`
	UltrafiltrationVol    float64 `json:"ultrafiltration_vol"`
	BPStatus              string  `json:"bp_status"`
	ActualUltrafiltration float64 `json:"actual_ultrafiltration"`
}

//	func GetNewDialysisBPDetailTableTen(user_org_id int64, start_time int64, end_time int64, addType, page, limit int64) ([]DialysisDataThree, int64, error) {
//		offset := (page - 1) * limit
//		var total int64
//		var results []DialysisDataThree
//		// SQL 查询
//		query := `
//			SELECT
//				p.dialysis_no AS 透析号,
//				p.name AS 患者姓名,
//				p.gender AS 性别,
//				FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS 年龄,
//				b.assessment_date AS 透析日期,
//				b.dry_weight AS 干体重,
//				CONCAT(b.systolic_blood_pressure, '/', b.diastolic_blood_pressure) AS 透前血压,
//				CONCAT(a.systolic_blood_pressure, '/', a.diastolic_blood_pressure) AS 透后血压,
//				GROUP_CONCAT(CONCAT(m.systolic_blood_pressure, '/', m.diastolic_blood_pressure) ORDER BY m.monitoring_date ASC SEPARATOR ',') AS 监测记录血压,
//				(SELECT mr.ultrafiltration_rate
//				 FROM xt_monitoring_record mr
//				 WHERE mr.patient_id = p.id AND mr.monitoring_date = b.assessment_date
//				 ORDER BY mr.operate_time DESC
//				 LIMIT 1) AS 超滤率,
//				(SELECT mr.ultrafiltration_volume
//				 FROM xt_monitoring_record mr
//				 WHERE mr.patient_id = p.id AND mr.monitoring_date = b.assessment_date
//				 ORDER BY mr.operate_time DESC
//				 LIMIT 1) AS 超滤总量,
//				CASE
//					WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
//						CASE
//							WHEN b.systolic_blood_pressure < 140 OR b.diastolic_blood_pressure < 90 THEN '达标'
//							ELSE '不达标'
//						END
//					WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
//						CASE
//							WHEN b.systolic_blood_pressure < 160 OR b.diastolic_blood_pressure < 90 THEN '达标'
//							ELSE '不达标'
//						END
//				END AS 血压达标状态
//			FROM
//				xt_patients p
//			JOIN
//				xt_assessment_before_dislysis b ON p.id = b.patient_id
//			JOIN
//				xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date
//			JOIN
//				xt_monitoring_record m ON p.id = m.patient_id AND m.monitoring_date = b.assessment_date
//			WHERE
//				b.user_org_id = ?
//				AND b.assessment_date >= ?
//				AND b.assessment_date <= ?
//				AND (
//					(? = 1 AND CASE
//						WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
//							CASE
//								WHEN b.systolic_blood_pressure < 140 OR b.diastolic_blood_pressure < 90 THEN 1
//								ELSE 0
//							END
//						WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
//							CASE
//								WHEN b.systolic_blood_pressure < 160 OR b.diastolic_blood_pressure < 90 THEN 1
//								ELSE 0
//							END
//					END = 1)
//					OR
//					(? = 2 AND CASE
//						WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
//							CASE
//								WHEN b.systolic_blood_pressure >= 140 AND b.diastolic_blood_pressure >= 90 THEN 1
//								ELSE 0
//							END
//						WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
//							CASE
//								WHEN b.systolic_blood_pressure >= 160 AND b.diastolic_blood_pressure >= 90 THEN 1
//								ELSE 0
//							END
//					END = 1)
//				)
//			GROUP BY
//				p.id, b.assessment_date
//			ORDER BY
//				p.id, b.assessment_date
//			LIMIT ? OFFSET ?;
//		`
//
//		// 计算总数
//		countQuery := `
//			SELECT COUNT(*)
//			FROM
//				xt_patients p
//			JOIN
//				xt_assessment_before_dislysis b ON p.id = b.patient_id
//			WHERE
//				b.user_org_id = ?
//				AND b.assessment_date >= ?
//				AND b.assessment_date <= ?
//		`
//
//		// 执行统计查询
//		if err := readDb.Raw(countQuery, user_org_id, start_time, end_time).Scan(&total).Error; err != nil {
//			return nil, 0, fmt.Errorf("error calculating total count: %v", err)
//		}
//
//		// 执行数据查询
//		if err := readDb.Raw(query, user_org_id, start_time, end_time, addType, addType, limit, offset).Scan(&results).Error; err != nil {
//			return nil, 0, fmt.Errorf("error executing query: %v", err)
//		}
//
//		return results, total, nil
//	}

func GetNewDialysisBPDetailTableTenOne(
	user_org_id int64,
	start_time int64,
	end_time int64,
	addType, page, limit int64,
) ([]DialysisDataThree, int64, error) {
	offset := (page - 1) * limit
	var results []DialysisDataThree
	var total int64

	// 构建基本查询
	query := readDb.Table("xt_assessment_after_dislysis b").
		Select(`
            p.dialysis_no AS dialysis_no,
			b.actual_ultrafiltration as actual_ultrafiltration,
            p.name AS patient_name,
            p.gender AS gender,
            FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
            b.assessment_date AS assessment_date,
            b.dry_weight AS dry_weight,
            CONCAT(a.systolic_blood_pressure, '/', a.diastolic_blood_pressure) AS pre_dialysis_bp,
            CONCAT(b.systolic_blood_pressure, '/', b.diastolic_blood_pressure) AS post_dialysis_bp,
            GROUP_CONCAT(CONCAT(m.systolic_blood_pressure, '/', m.diastolic_blood_pressure) ORDER BY m.monitoring_date ASC SEPARATOR ',') AS monitoring_bp,
            (
                SELECT mr.ultrafiltration_rate
                FROM xt_monitoring_record mr
                WHERE mr.patient_id = p.id 
                AND mr.monitoring_date = b.assessment_date
                ORDER BY mr.operate_time DESC LIMIT 1
            ) AS ultrafiltration_rate,
            (
                SELECT mr.ultrafiltration_volume
                FROM xt_monitoring_record mr
                WHERE mr.patient_id = p.id 
                AND mr.monitoring_date = b.assessment_date
                ORDER BY mr.operate_time DESC LIMIT 1
            ) AS ultrafiltration_vol,
            CASE 
                WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
                    CASE 
                        WHEN b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure <> 0 and  b.systolic_blood_pressure < 140 and b.diastolic_blood_pressure < 90 THEN '达标'
                        ELSE '不达标'
                    END
                WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
                    CASE 
                        WHEN b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure  <> 0 and  b.systolic_blood_pressure < 160 AND b.diastolic_blood_pressure < 90 THEN '达标'
                        ELSE '不达标'
                    END
            END AS bp_status
        `).
		Joins("JOIN xt_patients p ON p.id = b.patient_id").
		Joins("JOIN xt_assessment_before_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date").
		Joins("JOIN xt_monitoring_record m ON p.id = m.patient_id AND m.monitoring_date = b.assessment_date").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Group("p.id, b.assessment_date")

	// 根据传入的 addType 值动态构建条件
	switch addType {
	case 1:
		query = query.Where(`
			CASE 
				WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
				b.systolic_blood_pressure <> 0 and  b.diastolic_blood_pressure <> 0 and 	b.systolic_blood_pressure < 140 AND b.diastolic_blood_pressure < 90
				WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
					b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure <> 0 and b.systolic_blood_pressure < 160 AND b.diastolic_blood_pressure < 90
			END`)
	case 2:
		query = query.Where(`
			CASE 
				WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
					b.systolic_blood_pressure = 0 or  b.diastolic_blood_pressure = 0 or b.systolic_blood_pressure >= 140 OR b.diastolic_blood_pressure >= 90
				WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
					b.systolic_blood_pressure = 0 or  b.diastolic_blood_pressure = 0 or b.systolic_blood_pressure >= 160 OR b.diastolic_blood_pressure >= 90
			END`)
	}

	// 获取总记录数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}

	// 获取分页数据
	if err := query.Order("p.id, b.assessment_date").
		Offset(int(offset)).
		Limit(int(limit)).
		Scan(&results).Error; err != nil {
		return nil, 0, fmt.Errorf("query execution failed: %v", err)
	}

	return results, total, nil
}

func GetNewDialysisBPDetailTableTen(
	user_org_id int64,
	start_time int64,
	end_time int64,
	addType, page, limit int64,
) ([]DialysisDataThree, int64, error) {
	offset := (page - 1) * limit
	var results []DialysisDataThree
	var total int64

	// 构建基本查询
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
            p.dialysis_no AS dialysis_no,
			a.actual_ultrafiltration as actual_ultrafiltration,
            p.name AS patient_name,
            p.gender AS gender,
            FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
            b.assessment_date AS assessment_date,
            b.dry_weight AS dry_weight,
            CONCAT(b.systolic_blood_pressure, '/', b.diastolic_blood_pressure) AS pre_dialysis_bp,
            CONCAT(a.systolic_blood_pressure, '/', a.diastolic_blood_pressure) AS post_dialysis_bp,
            GROUP_CONCAT(CONCAT(m.systolic_blood_pressure, '/', m.diastolic_blood_pressure) ORDER BY m.monitoring_date ASC SEPARATOR ',') AS monitoring_bp,
            (
                SELECT mr.ultrafiltration_rate
                FROM xt_monitoring_record mr
                WHERE mr.patient_id = p.id 
                AND mr.monitoring_date = b.assessment_date
                ORDER BY mr.operate_time DESC LIMIT 1
            ) AS ultrafiltration_rate,
            (
                SELECT mr.ultrafiltration_volume
                FROM xt_monitoring_record mr
                WHERE mr.patient_id = p.id 
                AND mr.monitoring_date = b.assessment_date
                ORDER BY mr.operate_time DESC LIMIT 1
            ) AS ultrafiltration_vol,
            CASE 
                WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
                    CASE 
                        WHEN b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure <> 0 and  b.systolic_blood_pressure < 140 and b.diastolic_blood_pressure < 90 THEN '达标'
                        ELSE '不达标'
                    END
                WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
                    CASE 
                        WHEN b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure  <> 0 and  b.systolic_blood_pressure < 160 AND b.diastolic_blood_pressure < 90 THEN '达标'
                        ELSE '不达标'
                    END
            END AS bp_status
        `).
		Joins("JOIN xt_patients p ON p.id = b.patient_id").
		Joins("JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date").
		Joins("JOIN xt_monitoring_record m ON p.id = m.patient_id AND m.monitoring_date = b.assessment_date").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Group("p.id, b.assessment_date")

	// 根据传入的 addType 值动态构建条件
	switch addType {
	case 1:
		query = query.Where(`
			CASE 
				WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
				b.systolic_blood_pressure <> 0 and  b.diastolic_blood_pressure <> 0 and 	b.systolic_blood_pressure < 140 AND b.diastolic_blood_pressure < 90
				WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
					b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure <> 0 and b.systolic_blood_pressure < 160 AND b.diastolic_blood_pressure < 90
			END`)
	case 2:
		query = query.Where(`
			CASE 
				WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
					b.systolic_blood_pressure = 0 or  b.diastolic_blood_pressure = 0 or b.systolic_blood_pressure >= 140 OR b.diastolic_blood_pressure >= 90
				WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
					b.systolic_blood_pressure = 0 or  b.diastolic_blood_pressure = 0 or b.systolic_blood_pressure >= 160 OR b.diastolic_blood_pressure >= 90
			END`)
	}

	// 获取总记录数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}

	// 获取分页数据
	if err := query.Order("p.id, b.assessment_date").
		Offset(int(offset)).
		Limit(int(limit)).
		Scan(&results).Error; err != nil {
		return nil, 0, fmt.Errorf("query execution failed: %v", err)
	}

	return results, total, nil
}

func GetNewDialysisBPDetailTableTenThree(
	user_org_id int64,
	start_time int64,
	end_time int64,
) (item []otherItemAmount, err error) {
	var results []DialysisDataThree
	var total int64
	// 构建基本查询
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
            CASE 
                WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
                    CASE 
                        WHEN b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure <> 0 and b.systolic_blood_pressure < 140 AND b.diastolic_blood_pressure < 90 THEN '达标'
                        ELSE '不达标'
                    END
                WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
                    CASE 
                        WHEN b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure <> 0 and b.systolic_blood_pressure < 160 AND b.diastolic_blood_pressure < 90 THEN '达标'
                        ELSE '不达标'
                    END
            END AS bp_status
        `).
		Joins("JOIN xt_patients p ON p.id = b.patient_id").
		Joins("JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Group("p.id, b.assessment_date")
	// 获取总记录数
	query.Count(&total)
	// 获取分页数据
	query.Order("p.id, b.assessment_date").Scan(&results)
	var metStandard, unmetStandard int
	for _, result := range results {
		if result.BPStatus == "达标" {
			metStandard++

		} else {
			unmetStandard++
		}
	}

	if total > 0 {
		metPercentage := float64(metStandard) / float64(total) * 100
		unmetPercentage := float64(unmetStandard) / float64(total) * 100
		fmt.Printf("Total patients: %d\n", total)
		fmt.Printf("Met standard: %d (%.2f%%)\n", metStandard, metPercentage)
		fmt.Printf("Unmet standard: %d (%.2f%%)\n", unmetStandard, unmetPercentage)

		var items otherItemAmount
		items.Name = "达标患者"
		items.Ratio = strconv.FormatFloat(metPercentage, 'f', 1, 32)
		items.Total = int64(metStandard)
		item = append(item, items)

		var items2 otherItemAmount
		items2.Name = "未达标患者"
		items2.Ratio = strconv.FormatFloat(unmetPercentage, 'f', 1, 32)
		items2.Total = int64(unmetStandard)
		item = append(item, items2)
	}

	return
}

func GetNewDialysisBPDetailTableTenFour(
	user_org_id int64,
	start_time int64,
	end_time int64,
) (item []otherItemAmount, err error) {
	var results []DialysisDataThree
	var total int64
	// 构建基本查询
	query := readDb.Table("xt_assessment_after_dislysis b").
		Select(`
            CASE 
                WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) < 60 THEN
                    CASE 
                        WHEN b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure <> 0 and b.systolic_blood_pressure < 140 AND b.diastolic_blood_pressure < 90 THEN '达标'
                        ELSE '不达标'
                    END
                WHEN FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) >= 60 THEN
                    CASE 
                        WHEN b.systolic_blood_pressure <> 0 and b.diastolic_blood_pressure <> 0 and b.systolic_blood_pressure < 160 AND b.diastolic_blood_pressure < 90 THEN '达标'
                        ELSE '不达标'
                    END
            END AS bp_status
        `).
		Joins("JOIN xt_patients p ON p.id = b.patient_id").
		Joins("JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Group("p.id, b.assessment_date")
	// 获取总记录数
	query.Count(&total)
	// 获取分页数据
	query.Order("p.id, b.assessment_date").Scan(&results)
	var metStandard, unmetStandard int
	for _, result := range results {
		if result.BPStatus == "达标" {
			metStandard++

		} else {
			unmetStandard++
		}
	}

	if total > 0 {
		metPercentage := float64(metStandard) / float64(total) * 100
		unmetPercentage := float64(unmetStandard) / float64(total) * 100
		fmt.Printf("Total patients: %d\n", total)
		fmt.Printf("Met standard: %d (%.2f%%)\n", metStandard, metPercentage)
		fmt.Printf("Unmet standard: %d (%.2f%%)\n", unmetStandard, unmetPercentage)

		var items otherItemAmount
		items.Name = "达标患者"
		items.Ratio = strconv.FormatFloat(metPercentage, 'f', 1, 32)
		items.Total = int64(metStandard)
		item = append(item, items)

		var items2 otherItemAmount
		items2.Name = "未达标患者"
		items2.Ratio = strconv.FormatFloat(unmetPercentage, 'f', 1, 32)
		items2.Total = int64(unmetStandard)
		item = append(item, items2)
	}

	return
}

func GetNewDialysisWeightDetailTableTenT(
	user_org_id int64,
	start_time int64,
	end_time int64,
	addType, dryType, afterType, page, limit int64, keyword string, item_type int64) ([]DialysisDataTwo, int64, error) {
	offset := (page - 1) * limit
	//var dialysisData []DialysisDataTwo
	var total int64
	keyword = "%" + keyword + "%"
	var query *gorm.DB
	if item_type == 0 || item_type == 1 { //体重增加，以透后体重为分母
		// 构建基本查询
		query = readDb.Table("xt_assessment_before_dislysis b").
			Select(`
           p.dialysis_no AS dialysis_no,
           p.name AS patient_name,
           p.gender AS gender,
           FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
           b.assessment_date AS assessment_date,
           b.dry_weight AS dry_weight,
           b.weight_before AS weight_before,
           a.weight_after AS weight_after,
           (
               SELECT a2.weight_after
               FROM xt_assessment_after_dislysis a2
               JOIN xt_assessment_before_dislysis b2
               ON a2.patient_id = b2.patient_id
               AND a2.assessment_date = b2.assessment_date
               WHERE b2.patient_id = b.patient_id
               AND b2.assessment_date < b.assessment_date
               ORDER BY b2.assessment_date DESC LIMIT 1
           ) AS last_weight_after,
           CASE
               WHEN 
                    a.weight_after and b.dry_weight
                IS NOT NULL
               THEN a.weight_after - b.dry_weight
               ELSE NULL
           END AS weight_add,
           CASE
              WHEN a.weight_after IS NULL or a.weight_after = 0 THEN '其他'
               WHEN b.dry_weight IS NOT NULL THEN
                   CASE
                       WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
                       ELSE '不达标'
                   END
               ELSE '其他'
           END AS weight_status
       `).
			Joins("JOIN xt_patients p ON p.id = b.patient_id and p.name like ?", keyword).
			Joins("left JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
			Where("b.user_org_id = ?", user_org_id).
			Where("b.assessment_date >= ?", start_time).
			Where("b.assessment_date <= ?", end_time).
			Where("b.status = ?", 1)

	} else {

		query = readDb.Table("xt_assessment_before_dislysis b").
			Select(`
           p.dialysis_no AS dialysis_no,
           p.name AS patient_name,
           p.gender AS gender,
           FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
           b.assessment_date AS assessment_date,
           b.dry_weight AS dry_weight,
           b.weight_before AS weight_before,
           a.weight_after AS weight_after,
           (
               SELECT a2.weight_after
               FROM xt_assessment_after_dislysis a2
               JOIN xt_assessment_before_dislysis b2
               ON a2.patient_id = b2.patient_id
               AND a2.assessment_date = b2.assessment_date
               WHERE b2.patient_id = b.patient_id
               AND b2.assessment_date < b.assessment_date
               ORDER BY b2.assessment_date DESC LIMIT 1
           ) AS last_weight_after,
           CASE
               WHEN 
                    a.weight_after and b.dry_weight
                IS NOT NULL
               THEN a.weight_after - b.dry_weight
               ELSE NULL
           END AS weight_add,
           CASE
              WHEN a.weight_after IS NULL or a.weight_after = 0 THEN '其他'
               WHEN b.dry_weight IS NOT NULL THEN
                   CASE
                       WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
                       ELSE '不达标'
                   END
               ELSE '其他'
           END AS weight_status
       `).
			Joins("JOIN xt_patients p ON p.id = b.patient_id and p.name like ?", keyword).
			Joins("left JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
			Where("b.user_org_id = ?", user_org_id).
			Where("b.assessment_date >= ?", start_time).
			Where("b.assessment_date <= ?", end_time).
			Where("b.status = ?", 1)

	}

	switch dryType {
	case 5:
		query = query.Where("b.dry_weight < ?", 40)
	case 1:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 40, 50)
	case 2:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 50, 60)
	case 3:
		query = query.Where("b.dry_weight >= ? AND b.dry_weight < ?", 60, 70)
	case 4:
		query = query.Where("b.dry_weight >= ?", 70)
	case 6:
		query = query.Where("b.dry_weight IS NULL OR b.dry_weight = ''")
	}

	if item_type == 0 || item_type == 1 {
		switch addType {
		case 1:
			query = query.Where(`
        (
            CASE
                WHEN (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                ) IS NOT NULL
                THEN (b.weight_before - (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )) / (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )
                ELSE NULL
            END
        ) <= 0.03
    `)
		case 2:
			query = query.Where(`
        (
            CASE
                WHEN (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                ) IS NOT NULL
                THEN (b.weight_before - (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )) / (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )
                ELSE NULL
            END
        ) > 0.03 AND (
            CASE
                WHEN (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                ) IS NOT NULL
                THEN (b.weight_before - (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )) / (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )
                ELSE NULL
            END
        ) < 0.05
    `)
		case 3:
			query = query.Where(`
        (
            CASE
                WHEN (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                ) IS NOT NULL
                THEN (b.weight_before - (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )) / (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )
                ELSE NULL
            END
        ) >= 0.05
    `)
		case 4:
			query = query.Where(`
        (
            SELECT a2.weight_after
            FROM xt_assessment_after_dislysis a2
            JOIN xt_assessment_before_dislysis b2
            ON a2.patient_id = b2.patient_id
            AND a2.assessment_date = b2.assessment_date
            WHERE b2.patient_id = b.patient_id
            AND b2.assessment_date < b.assessment_date
            ORDER BY b2.assessment_date DESC LIMIT 1
        ) IS NULL
    `)
		}

	} else {
		switch addType {
		case 1:
			query = query.Where(`
        (
            CASE
                WHEN b.weight_before and b.dry_weight IS NOT NULL
                THEN (b.weight_before - b.dry_weight) / (
                   b.dry_weight
                )
                ELSE NULL
            END
        ) <= 0.03
    `)
		case 2:
			query = query.Where(`
        (
            CASE
                 WHEN b.weight_before and b.dry_weight IS NOT NULL
                THEN (b.weight_before - b.dry_weight) / (
                   b.dry_weight
                )
                ELSE NULL
            END
        ) > 0.03 AND (
            CASE
                 WHEN b.weight_before and b.dry_weight IS NOT NULL
                THEN (b.weight_before - b.dry_weight) / (
                   b.dry_weight
                )
                ELSE NULL
            END
        ) < 0.05
    `)
		case 3:
			query = query.Where(`
        (
            CASE
               WHEN b.weight_before and b.dry_weight IS NOT NULL
                THEN (b.weight_before - b.dry_weight) / (
                   b.dry_weight
                )
                ELSE NULL
            END
        ) >= 0.05
    `)
		case 4:
			query = query.Where(`b.weight_before and b.dry_weight  IS NULL`)
		}

	}

	switch afterType {
	case 1:
		query = query.Where(`
        CASE
            WHEN a.weight_after  IS NULL or a.weight_after = 0 THEN '其他'
            WHEN b.dry_weight IS NOT NULL THEN
                CASE
                    WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
                    ELSE '不达标'
                END
            ELSE '其他'
        END = ?`, "达标")
	case 2:
		query = query.Where(`
        CASE
            WHEN a.weight_after IS NULL or a.weight_after = 0  THEN '其他'
            WHEN b.dry_weight IS NOT NULL THEN
                CASE
                    WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
                    ELSE '不达标'
                END
            ELSE '其他'
        END = ?`, "不达标")
	case 3:
		query = query.Where(`
        CASE
            WHEN a.weight_after IS NULL or a.weight_after = 0 THEN '其他'
            WHEN b.dry_weight IS NOT NULL THEN
                CASE
                    WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
                    ELSE '不达标'
                END
            ELSE '其他'
        END = ?`, "其他")
	}

	//// 获取总记录数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}

	var data []DialysisDataTwo

	query.Order("p.id, b.assessment_date").Offset(int(offset)).Limit(int(limit)).Find(&data)

	return data, total, nil
}

func GetNewDialysisWeightDetailTableTenTenOne(
	user_org_id int64,
	start_time int64,
	end_time int64, add_type int64) ([]DialysisDataTwo, int64, error) {

	var total int64

	// 构建基本查询
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
           p.dialysis_no AS dialysis_no,
           p.name AS patient_name,
           p.gender AS gender,
           FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
           b.assessment_date AS assessment_date,
           b.dry_weight AS dry_weight,
           b.weight_before AS weight_before,
           a.weight_after AS weight_after,
           (
               SELECT a2.weight_after
               FROM xt_assessment_after_dislysis a2
               JOIN xt_assessment_before_dislysis b2
               ON a2.patient_id = b2.patient_id
               AND a2.assessment_date = b2.assessment_date
               WHERE b2.patient_id = b.patient_id
               AND b2.assessment_date < b.assessment_date
               ORDER BY b2.assessment_date DESC LIMIT 1
           ) AS last_weight_after,
           CASE
               WHEN (
                   SELECT a2.weight_after
                   FROM xt_assessment_after_dislysis a2
                   JOIN xt_assessment_before_dislysis b2
                   ON a2.patient_id = b2.patient_id
                   AND a2.assessment_date = b2.assessment_date
                   WHERE b2.patient_id = b.patient_id
                   AND b2.assessment_date < b.assessment_date
                   ORDER BY b2.assessment_date DESC LIMIT 1
               ) IS NOT NULL
               THEN (b.weight_before - (
                   SELECT a2.weight_after
                   FROM xt_assessment_after_dislysis a2
                   JOIN xt_assessment_before_dislysis b2
                   ON a2.patient_id = b2.patient_id
                   AND a2.assessment_date = b2.assessment_date
                   WHERE b2.patient_id = b.patient_id
                   AND b2.assessment_date < b.assessment_date
                   ORDER BY b2.assessment_date DESC LIMIT 1
               )) / (
                   SELECT a2.weight_after
                   FROM xt_assessment_after_dislysis a2
                   JOIN xt_assessment_before_dislysis b2
                   ON a2.patient_id = b2.patient_id
                   AND a2.assessment_date = b2.assessment_date
                   WHERE b2.patient_id = b.patient_id
                   AND b2.assessment_date < b.assessment_date
                   ORDER BY b2.assessment_date DESC LIMIT 1
               )
               ELSE NULL
           END AS weight_add,
           CASE
              WHEN a.weight_after IS NULL or a.weight_after = 0 THEN '其他'
               WHEN b.dry_weight IS NOT NULL THEN
                   CASE
                       WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
                       ELSE '不达标'
                   END
               ELSE '其他'
           END AS weight_status
       `).
		Joins("JOIN xt_patients p ON p.id = b.patient_id ").
		Joins("left JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Where("b.status = ?", 1)

	switch add_type {
	case 1:
		query = query.Where(`
        (
            CASE
                WHEN (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                ) IS NOT NULL
                THEN (b.weight_before - (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )) / (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )
                ELSE NULL
            END
        ) <= 0.03
    `)
	case 2:
		query = query.Where(`
        (
            CASE
                WHEN (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                ) IS NOT NULL
                THEN (b.weight_before - (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )) / (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )
                ELSE NULL
            END
        ) > 0.03 AND (
            CASE
                WHEN (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                ) IS NOT NULL
                THEN (b.weight_before - (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )) / (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )
                ELSE NULL
            END
        ) < 0.05
    `)
	case 3:
		query = query.Where(`
        (
            CASE
                WHEN (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                ) IS NOT NULL
                THEN (b.weight_before - (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )) / (
                    SELECT a2.weight_after
                    FROM xt_assessment_after_dislysis a2
                    JOIN xt_assessment_before_dislysis b2
                    ON a2.patient_id = b2.patient_id
                    AND a2.assessment_date = b2.assessment_date
                    WHERE b2.patient_id = b.patient_id
                    AND b2.assessment_date < b.assessment_date
                    ORDER BY b2.assessment_date DESC LIMIT 1
                )
                ELSE NULL
            END
        ) >= 0.05
    `)
	case 4:
		query = query.Where(`
        (
            SELECT a2.weight_after
            FROM xt_assessment_after_dislysis a2
            JOIN xt_assessment_before_dislysis b2
            ON a2.patient_id = b2.patient_id
            AND a2.assessment_date = b2.assessment_date
            WHERE b2.patient_id = b.patient_id
            AND b2.assessment_date < b.assessment_date
            ORDER BY b2.assessment_date DESC LIMIT 1
        ) IS NULL
    `)
	}

	//// 获取总记录数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}

	var data []DialysisDataTwo

	query.Order("p.id, b.assessment_date").Find(&data)

	return data, total, nil
}

func GetNewDialysisWeightDetailTableTenTenTwo(
	user_org_id int64,
	start_time int64,
	end_time int64, add_type int64) ([]DialysisDataTwo, int64, error) {

	var total int64

	// 构建基本查询
	query := readDb.Table("xt_assessment_before_dislysis b").
		Select(`
           p.dialysis_no AS dialysis_no,
           p.name AS patient_name,
           p.gender AS gender,
           FLOOR((YEAR(CURDATE()) - SUBSTRING(p.id_card_no, 7, 4))) AS age,
           b.assessment_date AS assessment_date,
           b.dry_weight AS dry_weight,
           b.weight_before AS weight_before,
           a.weight_after AS weight_after,
           (
               SELECT a2.weight_after
               FROM xt_assessment_after_dislysis a2
               JOIN xt_assessment_before_dislysis b2
               ON a2.patient_id = b2.patient_id
               AND a2.assessment_date = b2.assessment_date
               WHERE b2.patient_id = b.patient_id
               AND b2.assessment_date < b.assessment_date
               ORDER BY b2.assessment_date DESC LIMIT 1
           ) AS last_weight_after,
           CASE
               WHEN b.dry_weight and b.weight_before IS NOT NULL
               THEN (b.weight_before - b.dry_weight) / b.dry_weight
               ELSE NULL
           END AS weight_add,
           CASE
              WHEN a.weight_after IS NULL or a.weight_after = 0 THEN '其他'
               WHEN b.dry_weight IS NOT NULL THEN
                   CASE
                       WHEN ABS(a.weight_after - b.dry_weight) <= 0.3 THEN '达标'
                       ELSE '不达标'
                   END
               ELSE '其他'
           END AS weight_status
       `).
		Joins("JOIN xt_patients p ON p.id = b.patient_id ").
		Joins("left JOIN xt_assessment_after_dislysis a ON p.id = a.patient_id AND b.assessment_date = a.assessment_date AND a.status = 1").
		Where("b.user_org_id = ?", user_org_id).
		Where("b.assessment_date >= ?", start_time).
		Where("b.assessment_date <= ?", end_time).
		Where("b.status = ?", 1)

	switch add_type {
	case 1:
		query = query.Where(`
        (
            CASE
               WHEN b.dry_weight and b.weight_before IS NOT NULL
                THEN (b.weight_before -b.dry_weight) / b.dry_weight
                ELSE NULL
            END
        ) <= 0.03
    `)
	case 2:
		query = query.Where(`
        (
            CASE
               WHEN b.dry_weight and b.weight_before IS NOT NULL
                THEN (b.weight_before -b.dry_weight) / b.dry_weight
                ELSE NULL
            END
        ) > 0.03 AND (
           CASE
               WHEN b.dry_weight and b.weight_before IS NOT NULL
                THEN (b.weight_before -b.dry_weight) / b.dry_weight
                ELSE NULL
            END
        ) < 0.05
    `)
	case 3:
		query = query.Where(`
        ( 
			CASE
               WHEN b.dry_weight and b.weight_before IS NOT NULL
                THEN (b.weight_before -b.dry_weight) / b.dry_weight
                ELSE NULL
            END
            ) >= 0.05
    `)
	case 4:
		query = query.Where(`
        (
            b.dry_weight 
        ) IS NULL or  (
            b.weight_before 
        ) IS NULL  
    `)
	}

	//// 获取总记录数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("count query failed: %v", err)
	}

	var data []DialysisDataTwo

	query.Order("p.id, b.assessment_date").Find(&data)

	return data, total, nil
}