package service

import (
	"archive/zip"
	"bufio"
	"bytes"
	"fmt"
	"strconv"
	"strings"
	"text/template"

	"gitee.com/linqwen/momo/app/gen/model"
	"gitee.com/linqwen/momo/base"
)

type modelService struct {
	base.BaseService[model.ModelEntity]
}

func NewModelService() *modelService {
	return &modelService{
		BaseService: *base.NewBaseService(GenSqliteDb, model.ModelEntity{}),
	}
}

func (bs *modelService) GetById(id string) (*model.ModelEntity, error) {
	// 使用 GORM 根据 Id 查询记录,加载关联对象
	var result model.ModelEntity
	if err := bs.DB.Preload("Fields").First(&result, id).Error; err != nil {
		return nil, err
	}
	return &result, nil
}

// func (bs *modelService) Create(model models.ModelEntity) (*models.ModelEntity, error) {
// 	if err := bs.DB.Create(&model).Error; err != nil {
// 		return nil, fmt.Errorf("create model error %w", err)
// 	}
// 	return &model, nil
// tx := bs.DB.Begin()
// if err := tx.Create(&model).Error; err != nil {
// 	tx.Rollback()
// 	return nil, err
// }

// // 添加父ID给所有field
// for i := range model.Fields {
// 	model.Fields[i].MODEL_ID = model.Id
// }

// // 使用批量插入
// // 在事务中保存 fields
// if err := tx.CreateInBatches(model.Fields, len(model.Fields)).Error; err != nil {
// 	tx.Rollback()
// 	return nil, err
// }

// tx.Commit()

// }

// Update 实现基础服务接口中的更新方法
func (bs *modelService) Update(id string, dbModel model.ModelEntity) (*model.ModelEntity, error) {
	tx := bs.DB.Begin()
	intID, _ := strconv.ParseInt(id, 10, 64)
	if err := tx.Debug().Where("id = ?", intID).Unscoped().Delete(&bs.Model).Error; err != nil {
		return nil, err
	}
	if err := tx.Debug().Where("model_id = ?", intID).Unscoped().Delete(&model.FieldEntity{}).Error; err != nil {
		return nil, err
	}
	if err := tx.Create(&dbModel).Error; err != nil {
		tx.Rollback()
		return nil, err
	}
	// 遍历子表数据并创建
	for i, field := range dbModel.Fields {
		field.MODEL_ID = dbModel.Id // 确保子表记录了父表的ID
		if i == 0 {
			continue
		}
		if err := tx.Create(&field).Error; err != nil {
			tx.Rollback()
			return nil, err
		}
	}
	tx.Commit()
	return &dbModel, nil
}

// 在内存中创建文件并添加到ZIP文件中
func (bs *modelService) CreateFileInMemory(model_id string) (*bytes.Buffer, error) {
	var dbmodel model.ModelEntity
	if err := bs.DB.Preload("Fields").First(&dbmodel, model_id).Error; err != nil {
		return nil, fmt.Errorf("模型数据为空 %w", err)
	}
	categary_id := dbmodel.TMPL_GROUP_ID
	// 获取tmpl模板列表
	var tmpls []model.TmplEntity
	if err := bs.DB.Where("categary_id = ?", categary_id).Where("status = ?", 1).Find(&tmpls).Error; err != nil {
		return nil, fmt.Errorf("tmpls is null %+w ", err)
	} else if len(tmpls) == 0 {
		return nil, fmt.Errorf("tmpls is null %w", err)
	}
	// 创建一个字节缓冲区用于存储ZIP文件
	var buf bytes.Buffer
	zipWriter := zip.NewWriter(&buf)

	// 循环创建所有的模板并添加到ZIP文件中
	for _, tmpl := range tmpls {
		path := strings.ReplaceAll(tmpl.PATH, "%s", dbmodel.MODEL_NAME)
		if err := createFile(tmpl.CONTENT, path, dbmodel, zipWriter); err != nil {
			return nil, fmt.Errorf("模板文件%s解析错误%w", path, err)
		}
	}

	// 关闭ZIP Writer
	if err := zipWriter.Close(); err != nil {
		return nil, fmt.Errorf("zipwriter.close error%w", err)
	}

	return &buf, nil
}

func createFile(content string, path string, dbModel model.ModelEntity, zipWriter *zip.Writer) error {
	// 使用完整路径作为文件名
	modelPath := path
	// 设置ZIP文件条目的文件头
	fileHeader := &zip.FileHeader{
		Name:   modelPath,
		Method: zip.Deflate,
		// Mode:   0644,       // 设置文件权限
		// Mtime:  time.Now(), // 设置修改时间
	}
	// 从zip.Writer创建一个新的写入器
	writer, err := zipWriter.CreateHeader(fileHeader)
	if err != nil {
		return fmt.Errorf("创建zipwriter失败%w", err)
	}
	// 缓冲写入器
	bufferedWriter := bufio.NewWriter(writer)
	// 执行模板
	tmpl, err := template.New("template").Parse(content)
	if err != nil {
		return fmt.Errorf("error parsing template: %w", err)
	}
	// 将模板数据写入到ZIP文件的条目中
	data := map[string]interface{}{
		"Model": dbModel,
	}
	if err := tmpl.Execute(bufferedWriter, data); err != nil {
		return fmt.Errorf("tmpl.execute error: %w", err)
	}
	// 确保所有数据都被写入
	if err := bufferedWriter.Flush(); err != nil {
		return fmt.Errorf("flush error %w", err)
	}
	return nil
}

// 在内存中创建文件并添加到ZIP文件中，接受模型ID数组
func (bs *modelService) CreateFilesInMemory(model_ids []string) (*bytes.Buffer, error) {
	// 创建一个字节缓冲区用于存储ZIP文件
	var buf bytes.Buffer
	zipWriter := zip.NewWriter(&buf)

	// 循环遍历每个模型ID
	for _, model_id := range model_ids {
		var dbmodel model.ModelEntity
		if err := bs.DB.Preload("Fields").First(&dbmodel, model_id).Error; err != nil {
			zipWriter.Close()
			return nil, fmt.Errorf("模型数据为空 %w", err)
		}
		categary_id := dbmodel.TMPL_GROUP_ID

		// 获取tmpl模板列表
		var tmpls []model.TmplEntity
		if err := bs.DB.Where("categary_id = ?", categary_id).Where("status = ?", 1).Find(&tmpls).Error; err != nil {
			zipWriter.Close()
			return nil, fmt.Errorf("tmpls is null %w", err)
		} else if len(tmpls) == 0 {
			zipWriter.Close()
			return nil, fmt.Errorf("tmpls is null %w", err)
		}

		// 循环创建所有的模板并添加到ZIP文件中
		for _, tmpl := range tmpls {
			path := strings.ReplaceAll(tmpl.PATH, "%s", dbmodel.MODEL_NAME)
			if err := createFile(tmpl.CONTENT, path, dbmodel, zipWriter); err != nil {
				zipWriter.Close()
				return nil, fmt.Errorf("模板文件%s解析错误%w", path, err)
			}
		}
	}

	// 关闭ZIP Writer
	if err := zipWriter.Close(); err != nil {
		return nil, fmt.Errorf("zipwriter.close error%w", err)
	}

	return &buf, nil
}