package xugu

import (
	"bufio"
	"encoding/binary"
	"errors"
	"fmt"
	"net"
)

// ----------------------------------------------------------------------------------------------------
type SrvResponse struct {
	FormArgDescri []*FormArgDescri
	SelectResult  []*SelectResult
	InsertResult  []*InsertResult
	UpdateResult  []*UpdateResult
	DeleteResult  []*DeleteResult
	ProcRet       []*ProcRet
	OutParamRet   []*OutParamRet
	ErrInfo       []*ErrInfo
	WarnInfo      []*WarnInfo
	Message       []*Message
}

// func parseResponse(conn net.Conn) (*SrvResponse, error) {
// 	response := &SrvResponse{}
// 	reader := bufio.NewReader(conn)

// 	for {
// 		msgType, err := reader.ReadByte()
// 		if err != nil {
// 			return nil, err
// 		}

// 		switch msgType {
// 		case '$':
// 			argDescri, err := parseFormArgDescri(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.FormArgDescri = append(response.FormArgDescri, argDescri)

// 		case 'I':
// 			insertResult, err := parseInsertResult(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.InsertResult = append(response.InsertResult, insertResult)
// 		case 'U':
// 			updateResult, err := parseUpdateResult(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.UpdateResult = append(response.UpdateResult, updateResult)
// 		case 'D':
// 			deleteResult, err := parseDeleteResult(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.DeleteResult = append(response.DeleteResult, deleteResult)
// 		case 'O':
// 			procRet, err := parseProcRet(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.ProcRet = append(response.ProcRet, procRet)
// 		case 'P':
// 			outParamRet, err := parseOutParamRet(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.OutParamRet = append(response.OutParamRet, outParamRet)
// 		case 'E':
// 			errInfo, err := parseErrInfo(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.ErrInfo = append(response.ErrInfo, errInfo)
// 		case 'W':
// 			warnInfo, err := parseWarnInfo(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.WarnInfo = append(response.WarnInfo, warnInfo)
// 		case 'M':
// 			message, err := parseMessage(reader)
// 			if err != nil {
// 				return nil, err
// 			}
// 			response.Message = append(response.Message, message)
// 		case 'K':
// 			return response, nil
// 		default:
// 			return nil, fmt.Errorf("未知的消息类型: %v", msgType)
// 		}
// 	}
// }

// 解析函数的实现，例如 parseFormArgDescri 等

func readString(reader *bufio.Reader, length int) (string, error) {
	bytes := make([]byte, length)
	_, err := reader.Read(bytes)
	return string(bytes), err
}

func parseFieldDescri(reader *bufio.Reader) (FieldDescri, error) {
	fieldDescri := FieldDescri{}
	var err error

	fieldDescri.FieldNameLen, err = readInt32(reader)
	if err != nil {
		return fieldDescri, err
	}
	fieldDescri.FieldName, err = readString(reader, fieldDescri.FieldNameLen)
	if err != nil {
		return fieldDescri, err
	}
	// fieldDescri.FieldType, err = fieldType(reader)
	// if err != nil {
	// 	return fieldDescri, err
	// }
	fieldDescri.FieldPreciScale, err = readInt32(reader)
	if err != nil {
		return fieldDescri, err
	}
	fieldDescri.FieldFlag, err = readInt32(reader)
	if err != nil {
		return fieldDescri, err
	}

	return fieldDescri, nil
}

func xgSockRecvCommand(pConn *xuguConn) {

}

func xgSockRecvData(conn net.Conn, buffer *[]byte) (int, error) {
	// 接收服务器的返回消息
	n, err := conn.Read(*buffer)
	if err != nil {
		fmt.Println("接收服务器消息错误Error reading from server:", err)
		return 0, err
	}
	return n, nil
}

// TODO : pConn.bkChar != 0x0  这一部分代码需要修改
func rhRecv(pConn *xuguConn, buff []byte, dLen uint32) error {
	//old_len := dLen
	if pConn.bkChar != 0x0 {
		buff[0] = pConn.bkChar
		pConn.bkChar = 0x0
		//buff = buff[1:]
		dLen--
	}
	//接收加密登录信息
	if dLen != 0 {
		for dLen != 0 {
			if pConn.useSSL {
				buffer := make([]byte, 1024)
				n, err := pConn.conn.Read(buffer)
				if err != nil {
					return err
				} else {
					//xgCacheRecv(pConn, buffer, int32(n))
				}
				if n <= 0 {
					return errors.New("read error")
				}

			}
		}
		//	DECRYPT(p_conn, buff, old_len); //解密缓冲
	}
	return nil
}

// 接收单个字符
func rhRecvChar(pConn *xuguConn, valp *byte) (bool, error) {

	var ch [1]byte
	err := rhRecv(pConn, ch[:], 1)
	if err != nil {
		return false, err
	}
	fmt.Println("ch[] = ", ch[:])
	*valp = ch[0]
	return true, nil

}

//读取检查一个字符

func rhRecvStr(pConn *xuguConn, valp *[]byte) (int, error) {
	var len uint32
	if err := rhRecvInt32(pConn, &len); err != nil {
		return -4, err
	}
	pBuff := make([]byte, len+1)
	if err := rhRecv(pConn, pBuff, len); err != nil {
		return -4, err
	}
	pBuff[len] = 0x0
	*valp = pBuff
	return 0, nil
}
func rhRecvInt32(pconn *xuguConn, i *uint32) error {
	var buff [4]byte
	err := rhRecv(pconn, buff[:], 4)
	if err != nil {
		return err
	}

	// 将大端字节序转换为主机字节序
	*i = binary.BigEndian.Uint32(buff[:])

	return nil
}

// // 从连接中接收字段信息，并将其存储在 Result 结构体中。
// func recvFiledsInfo(pConn *xuguConn, pRes *Result) (int, error) {
// 	var fieldNum uint32

// 	//var pRet *FieldInfo
// 	if err := rhRecvInt32(pConn, &fieldNum); err != nil {
// 		return XG_NET_ERROR, err
// 	}
// 	if fieldNum > 4000 {
// 		return XG_NET_ERROR, errors.New("fieldNum >4000")
// 	}

// 	pRes.FieldNum = fieldNum

// 	pRet := make([]FieldInfo, fieldNum)
// 	//接收字段详细信息
// 	for n := uint32(0); n < fieldNum; n++ {
// 		if ret, err := recvAttrDesItem(pConn, &pRet[n]); err != nil {
// 			return ret, err
// 		}
// 	}

// 	bytesN := (fieldNum*2 + 7) / 8
// 	for n := uint32(0); n < fieldNum; n++ {
// 		pRet[n].Offset = bytesN
// 		bytesN += uint32(getSQLCType(pRet[n].TypeID))
// 	}
// 	// TODO : 这里需要重新修改
// 	// 在c代码中这里还加上了 ROW_HEAD_SIZE
// 	pRes.RowSize = bytesN + 24
// 	pRes.ColInfos = pRet

// 	return 0, nil
// }

// // 接收字段属性描述
// func recvAttrDesItem(pConn *xuguConn, pItem *FieldInfo) (int, error) {
// 	var nameLen uint32
// 	var tabName []byte
// 	var alias []byte

// 	if err := rhRecvInt32(pConn, &nameLen); err != nil {
// 		return XG_NET_ERROR, err
// 	}
// 	if nameLen > 1024 {
// 		return XG_NET_ERROR, errors.New("nameLen >1024")
// 	}
// 	var name []byte
// 	if err := rhRecv(pConn, name, nameLen); err != nil {
// 		return XG_NET_ERROR, err
// 	}

// 	if ret := bytes.IndexByte(name, '%'); ret != -1 {
// 		alias = name[ret+1:]
// 		name = name[:ret-1]
// 	}

// 	if ret := bytes.IndexByte(name, '.'); ret != -1 {
// 		//如果 return_schema_on 为真，那么这里将得到 schema_name.tab_name。
// 		tabName = name[:ret-1]
// 		name = name[ret+1:]
// 	}

// 	pItem.TabName = string(tabName)
// 	pItem.Name = string(name)
// 	pItem.Alias = string(alias)

// 	if err := rhRecvInt32(pConn, &pItem.TypeID); err != nil {
// 		return XG_NET_ERROR, err
// 	}
// 	if err := rhRecvInt32(pConn, &pItem.Modi); err != nil {
// 		return XG_NET_ERROR, err
// 	}
// 	if err := rhRecvInt32(pConn, &pItem.Flags); err != nil {
// 		return XG_NET_ERROR, err
// 	}

// 	pItem.CTypeID = uint32(getSQLCType(pItem.TypeID))

// 	return 0, nil
// }

func readInt32(reader *bufio.Reader) (int, error) {
	var value int32
	err := binary.Read(reader, binary.BigEndian, &value)
	return int(value), err
}

//接收结果集
//int  recv_Query_Rs(Conn_Attrs* p_conn,Result** pp_res,int*field_num,int64* rowcount,int* effected_num)
/* recv_Query_Rs :
* p_conn conn inout
* pp_res  output
 */
// func recvQueryRs(pConn *xuguConn, ppRes **Result) int {
// 	ret := 0
// 	pres := &Result{}
// 	pres_H := &Result{}
// 	for {
// 		var ch byte
// 		rhRecvChar(pConn, &ch)
// 		switch ch {
// 		case 'k':
// 			if pres_H != nil {
// 				*ppRes = pres_H
// 			} else {
// 				*ppRes = pres
// 			}
// 			return ret

// 		case 'E', 'F':
// 			var errStr []byte
// 			rhRecvStr(pConn, &errStr)
// 			fmt.Printf("[EC031]Error in recv result :%s \n", errStr)
// 			pConn.errStr = errStr
// 			ret = XG_ERROR
// 			continue

// 		case 'W', 'M':
// 			var errStr []byte
// 			rhRecvStr(pConn, &errStr)
// 			fmt.Printf("[EC032]Server Warning in recv result :%s \n", errStr)
// 			pConn.errStr = errStr
// 			ret = XG_ERROR // cyj 是否有点错误
// 		case 'I':
// 			//var len uint32
// 			// if !rhRecvInt32(pConn, &len) {

// 			// }

// 		case 'U', 'D':
// 		case 'A':
// 			if pres == nil {
// 				pres := &Result{}
// 				pres.Type = HT_RS
// 			} else {
// 				var prev = &Result{}
// 				if pres_H != nil {
// 					prev = pres_H
// 					for prev.NextResult != nil {
// 						prev = prev.NextResult
// 					}
// 				} else {
// 					pres_H = pres
// 					prev = pres_H
// 				}
// 				pres = &Result{}
// 				pres.Type = HT_RS
// 				prev.NextResult = pres
// 			}
// 			pres.SQLType = SQL_SELECT
// 			pres.DbcFlob = pConn

// 			// _, err := recvFiledsInfo(pConn, pres)
// 			// if err != nil {
// 			// 	return XG_SOCKET_ERROR,
// 			// }

// 		}

// 	}
// 	return 0
// }

// recv_record
// func recvRecords20000(p_conn *Conn_Attrs, p_res *Result) int {
// 	pRow := RhRow{}

// 	// if p_res.PBlokmemls == nil{
// 	// 	p_res.PBlokmemls =
// 	// }

// 	for i := 0; i < 20000; i++ {
// 		//recvRecord(p_conn, p_res, &pRow)
// 	}
// }

func recvRecord() {

}