package config

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"path"
	"runtime"
	"strings"
	"testing"

	"golang.org/x/crypto/ssh"
)

func getCurrentPath() string {
	_, filename, _, _ := runtime.Caller(1)

	return path.Dir(filename)
}
func TestGetConfigInfo(t1 *testing.T) {
	var config ConfigInfo
	config.GetConfigInfo("../../file/test.txt")
	fmt.Println(config)
}
func TestReadFile(t1 *testing.T) {
	fmt.Println(getCurrentPath())
	var config ConfigInfo
	//config.GetConfigInfo("../../file/test.txt")
	configRet := config.ReadCofing("../../file/test.txt")
	fmt.Println(configRet)
	fmt.Println("-------------------ParseConfigSql------------------------")
	retXugu := config.ParseConfigSql(configRet["xugu"])
	retSql := config.ParseConfigSql(configRet["sql"])
	for _, v := range retXugu {
		fmt.Println("retXugu", v)
	}
	for _, v := range retSql {
		fmt.Println("retSql", v)
	}
	fmt.Println("------------------ParseGroupCase---------------------------")
	var a map[string]string
	for _, v := range retXugu {
		a = config.ParseGroupCase(v)
		fmt.Println("ParseSqlCase:", a)
	}
	fmt.Println("a", a["port"])

	var b map[string]string
	for _, v := range retSql {
		b = config.ParseGroupCase(v)
		fmt.Println("ParseSqlCase:", b)
	}
}

var str = ` --删除测试表
DROP TABLE IF EXISTS INTERVAL_TABLE; 
--创建表，表列类型时间间隔
!!! 
CREATE TABLE INTERVAL_TABLE(
A INTERVAL YEAR,
B INTERVAL MONTH,
C INTERVAL DAY,
D INTERVAL HOUR,
E INTERVAL MINUTE,
F INTERVAL SECOND,
G INTERVAL YEAR TO MONTH,
H INTERVAL DAY TO HOUR,
I INTERVAL DAY TO MINUTE,
J INTERVAL DAY TO SECOND,
K INTERVAL HOUR TO MINUTE,
L INTERVAL HOUR TO SECOND,
M INTERVAL MINUTE TO SECOND);
   !!!
--插入数据
   !!! 
INSERT INTO INTERVAL_TABLE VALUES(
'1',
'2',
'3',
'4',
'5',
'6',
'12-1',
'10 1',
'10 11:01',
'10 10:10:01',
'10:10',
'10:10:10',
'10:10');
!!! 
--查询表数据
SELECT * FROM INTERVAL_TABLE;
--删除表
drop table INTERVAL_TABLE;`

func TestAnalysisFile(t1 *testing.T) {
	var tests string
	var sql string
	partTestStepScanner := bufio.NewScanner(strings.NewReader(str))
	for partTestStepScanner.Scan() {
		partLine := partTestStepScanner.Text()
		partLine = strings.TrimSpace(partLine)
		if strings.HasPrefix(partLine, "--") {
			fmt.Println("检测到--", partLine)
			continue
		}
		if strings.HasPrefix(partLine, "!!!") {
			fmt.Println("检测到!!!", partLine)
			for partTestStepScanner.Scan() {
				partLine := partTestStepScanner.Text()
				sql += partLine
				fmt.Println("partLine2:", partLine)
			}
			continue
		}
		fmt.Println("sql:", sql)
		tests = partLine
		fmt.Println("tests:", tests)
	}
	//fmt.Println("tests", tests)

}

func TestName(t *testing.T) {
	// 远程SSH服务器地址和端口
	sshAddr := "10.28.20.101:22"
	// SSH登录用户名
	sshUser := "root"
	// SSH登录密码或密钥

	// 配置SSH客户端
	config := &ssh.ClientConfig{
		User: sshUser,
		Auth: []ssh.AuthMethod{
			ssh.Password("Xugu@2023"),
		},
		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
	}

	// 连接到远程主机
	conn, err := ssh.Dial("tcp", sshAddr, config)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	// 创建SSH会话
	session, err := conn.NewSession()
	if err != nil {
		panic(err)
	}
	defer session.Close()

	// 执行远程命令

	// 创建输出管道
	stdout, err := session.StdoutPipe()
	if err != nil {
		panic(err)
	}

	// 启动远程命令
	_ = session.Start("pwd")
	if err != nil {
		panic(err)
	}

	// 从输出管道读取命令输出
	go func() {
		_, err := io.Copy(os.Stdout, stdout)
		if err != nil {
			panic(err)
		}
	}()

	// 等待命令执行完成
	err = session.Wait()
	if err != nil {
		panic(err)

	}
}