// Package configure 使用示例
//
// 以下示例演示如何使用配置中心客户端SDK
package test

import (
	"context"
	"fmt"
	"log"
	"time"

	"git.x2erp.com/qdy/go-base/model/request/queryreq"
	"git.x2erp.com/qdy/go-base/sdk/configure"
)

// ExampleUsage 演示SDK的基本用法
func ExampleUsage() {
	// 示例1：创建客户端
	exampleCreateClient()

	// 示例2：查询列表
	exampleListTables()

	// 示例3：创建表
	exampleSaveTable()

	// 示例4：查询详情
	exampleGetTable()

	// 示例5：删除表
	exampleDeleteTable()

	// 示例6：批量保存表
	exampleBatchSaveTables()

	// 示例7：用户登录
	exampleLoginUser()

}

func exampleCreateClient() {
	fmt.Println("=== 示例1：创建客户端 ===")

	// 方法1：使用默认配置
	client1, err := configure.NewClient()
	if err != nil {
		log.Printf("Failed to create default client: %v", err)
	} else {
		fmt.Printf("Default client created: URL=%s\n", client1.GetConfig().BaseURL)
	}

	// 方法2：使用Basic认证
	if _, err := configure.NewBasicAuthClient("http://localhost:8080", "admin", "123"); err != nil {
		log.Printf("Failed to create basic auth client: %v", err)
	} else {
		fmt.Println("Basic auth client created")
	}

	// 方法3：使用Token认证
	if _, err := configure.NewTokenAuthClient("http://localhost:8080", "your-token-here"); err != nil {
		log.Printf("Failed to create token auth client: %v", err)
	} else {
		fmt.Println("Token auth client created")
	}

	fmt.Println()
}

func exampleListTables() {
	fmt.Println("=== 示例2：查询数据库表字典列表 ===")

	// 创建客户端
	client, err := configure.NewBasicAuthClient("http://localhost:8080", "admin", "123")
	if err != nil {
		log.Printf("Failed to create client: %v", err)
		return
	}

	// 创建查询请求
	query := &configure.DicTableQueryRequest{
		QueryRequest: queryreq.QueryRequest{
			Page:     0,
			PageSize: 10,
		},
	}

	// 执行查询
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	result, err := client.ListTables(ctx, query)
	if err != nil {
		log.Printf("Error listing tables: %v", err)
		return
	}

	fmt.Printf("Total tables: %d\n", result.TotalCount)
	fmt.Printf("Last page: %d\n", result.LastPage)
	fmt.Println()
}

func exampleSaveTable() {
	fmt.Println("=== 示例3：创建数据库表字典 ===")

	// 创建客户端
	client, err := configure.NewBasicAuthClient("http://localhost:8080", "admin", "123")
	if err != nil {
		log.Printf("Failed to create client: %v", err)
		return
	}

	// 创建请求
	req := &configure.DicTableRequest{
		TableID:     "example_table_001",
		TableType:   "实体表",
		Name:        "示例表001",
		Description: "这是一个示例表",
		Fields: []configure.DicTableFieldRequest{
			{
				FieldID:     "example_table_001.id",
				TableID:     "example_table_001",
				FiledType:   "实际字段",
				DataType:    "数值型",
				FieldName:   "id",
				FieldNameCN: "主键ID",
				Description: "主键字段",
			},
			{
				FieldID:     "example_table_001.name",
				TableID:     "example_table_001",
				FiledType:   "实际字段",
				DataType:    "字符型",
				FieldName:   "name",
				FieldNameCN: "名称",
				Description: "名称字段",
			},
		},
	}

	// 执行保存
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	detail, err := client.SaveTable(ctx, req)
	if err != nil {
		log.Printf("Error saving table: %v", err)
		return
	}

	fmt.Printf("Table saved successfully: %s\n", detail.Table.TableID)
	fmt.Printf("Table name: %s\n", detail.Table.Name)
	fmt.Printf("Number of fields: %d\n", len(detail.Fields))
	fmt.Println()
}

func exampleGetTable() {
	fmt.Println("=== 示例4：查询数据库表字典详情 ===")

	// 创建客户端
	client, err := configure.NewBasicAuthClient("http://localhost:8080", "admin", "123")
	if err != nil {
		log.Printf("Failed to create client: %v", err)
		return
	}

	// 查询表详情
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	tableID := "example_table_001"
	detail, err := client.GetTable(ctx, tableID)
	if err != nil {
		if err == configure.ErrNotFound {
			fmt.Printf("Table %s not found\n", tableID)
		} else {
			log.Printf("Error getting table: %v", err)
		}
		return
	}

	fmt.Printf("Table ID: %s\n", detail.Table.TableID)
	fmt.Printf("Table Type: %s\n", detail.Table.TableType)
	fmt.Printf("Name: %s\n", detail.Table.Name)
	fmt.Printf("Description: %s\n", detail.Table.Description)
	fmt.Printf("Creator: %s\n", detail.Table.Creator)
	fmt.Printf("Fields count: %d\n", len(detail.Fields))
	fmt.Println()
}

func exampleDeleteTable() {
	fmt.Println("=== 示例5：删除数据库表字典 ===")

	// 创建客户端
	client, err := configure.NewBasicAuthClient("http://localhost:8080", "admin", "123")
	if err != nil {
		log.Printf("Failed to create client: %v", err)
		return
	}

	// 删除表
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	tableID := "example_table_001"
	if err := client.DeleteTable(ctx, tableID); err != nil {
		if err == configure.ErrNotFound {
			fmt.Printf("Table %s not found\n", tableID)
		} else {
			log.Printf("Error deleting table: %v", err)
		}
		return
	}

	fmt.Printf("Table %s deleted successfully\n", tableID)
	fmt.Println()
}

func exampleBatchSaveTables() {
	fmt.Println("=== 示例6：批量保存数据库表字典 ===")

	// 创建客户端（使用Token认证）
	// 注意：实际使用时需要从认证服务获取有效的token
	client, err := configure.NewTokenAuthClient("http://localhost:8080", "your-valid-token-here")
	if err != nil {
		log.Printf("Failed to create client: %v", err)
		return
	}

	// 创建批量保存请求
	req := &configure.BatchSaveDicTablesRequest{
		Tables: []configure.DicTableRequest{
			{
				TableID:     "batch_table_001",
				TableType:   "实体表",
				Name:        "批量测试表001",
				Description: "批量测试表001描述",
			},
			{
				TableID:     "batch_table_002",
				TableType:   "视图",
				Name:        "批量测试表002",
				Description: "批量测试表002描述",
			},
		},
		Fields: []configure.DicTableFieldRequest{
			// 表1的字段
			{
				FieldID:     "batch_table_001.id",
				TableID:     "batch_table_001",
				FiledType:   "实际字段",
				DataType:    "数值型",
				FieldName:   "id",
				FieldNameCN: "主键ID",
				Description: "表1主键字段",
			},
			{
				FieldID:     "batch_table_001.name",
				TableID:     "batch_table_001",
				FiledType:   "实际字段",
				DataType:    "字符型",
				FieldName:   "name",
				FieldNameCN: "名称",
				Description: "表1名称字段",
			},
			// 表2的字段
			{
				FieldID:     "batch_table_002.code",
				TableID:     "batch_table_002",
				FiledType:   "实际字段",
				DataType:    "字符型",
				FieldName:   "code",
				FieldNameCN: "编码",
				Description: "表2编码字段",
			},
			{
				FieldID:     "batch_table_002.value",
				TableID:     "batch_table_002",
				FiledType:   "计算字段",
				DataType:    "数值型",
				FieldName:   "value",
				FieldNameCN: "数值",
				Description: "表2数值字段",
			},
		},
	}

	// 执行批量保存
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	fmt.Println("开始批量保存2个表，4个字段...")
	startTime := time.Now()

	if err := client.BatchSaveTables(ctx, req); err != nil {
		log.Printf("批量保存失败: %v", err)
		return
	}

	elapsed := time.Since(startTime)
	fmt.Printf("批量保存成功！耗时: %v\n", elapsed)
	fmt.Println("注意：示例中的token需要替换为实际有效的token")
	fmt.Println("批量保存逻辑包括：")
	fmt.Println("  1. 字段字典：先删除表的所有字段，再批量插入")
	fmt.Println("  2. 表字典：存在则UPDATE，不存在则INSERT")
	fmt.Println()
}

func exampleLoginUser() {
	fmt.Println("=== 示例7：用户登录 ===")

	// 创建客户端（登录端点无需认证，但需要配置中心地址）
	// 注意：登录端点本身不需要认证，但客户端需要BaseURL
	client, err := configure.NewBasicAuthClient("http://localhost:8080", "admin", "123")
	if err != nil {
		log.Printf("Failed to create client: %v", err)
		return
	}

	// 创建登录请求
	req := &configure.UserLoginRequest{
		UserID:   "testuser",
		Password: "testpass",
	}

	// 执行登录
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	fmt.Println("尝试用户登录...")
	startTime := time.Now()

	token, err := client.LoginUser(ctx, req)
	if err != nil {
		log.Printf("登录失败: %v", err)
		return
	}

	elapsed := time.Since(startTime)
	fmt.Printf("登录成功！耗时: %v\n", elapsed)
	fmt.Printf("获取的Token: %s\n", token)
	fmt.Println()

	// 使用获取的token创建新的认证客户端
	fmt.Println("使用获取的Token创建新的认证客户端...")
	tokenClient, err := configure.NewTokenAuthClient("http://localhost:8080", token)
	if err != nil {
		log.Printf("Failed to create token client: %v", err)
		return
	}

	fmt.Printf("Token客户端创建成功，BaseURL: %s\n", tokenClient.GetConfig().BaseURL)
	fmt.Println("注意：实际使用时需要有效的用户凭证和正确的配置中心地址")
	fmt.Println()
}