package redisLog

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"gitee.com/qq358678184_admin/gcore"
	"gitee.com/qq358678184_admin/gcore/dbUtils"
	"gitee.com/qq358678184_admin/gcore/logHelper"
	"io/ioutil"
	"net"
	"os"
	"sync"
)

type RedisDbLogSender struct {
	MaxIndex int
	conn     net.Conn
	lock     sync.Mutex
}

var redisDbLogSenderOnce sync.Once
var redisDbLogSender *RedisDbLogSender

func NewRedisDbLogSender() *RedisDbLogSender {
	redisDbLogSenderOnce.Do(func() {
		redisDbLogSender = &RedisDbLogSender{}
		redisDbLogSender.MaxIndex = 655350000
	})
	return redisDbLogSender
}

func (d *RedisDbLogSender) GetOldFirstFilePath() (string, error) {
	files, err := ioutil.ReadDir("dblog/redisSenderLogs")
	if err != nil {
		return "", err
	}
	if len(files) == 0 {
		return "", nil
	}

	var tempFile = files[0]
	for _, file := range files {
		if file.ModTime().Before(tempFile.ModTime()) {
			tempFile = file
		}
	}
	filePath := fmt.Sprintf("dblog/redisSenderLogs/%s", tempFile.Name())
	fmt.Println("find file", filePath)
	return filePath, nil
}

func (d *RedisDbLogSender) StartSendFile() {
	path, err := d.GetOldFirstFilePath()
	if err != nil {
		logHelper.Error(err)
		return
	}
	if path == "" {
		return
	}

	bytes, err := ioutil.ReadFile(path)
	if err != nil {
		logHelper.Error(err)
		return
	}
	err = d.Send(bytes)
	if err != nil {
		fmt.Println(err)
		return
	}
	err = os.Remove(path)
	if err != nil {
		logHelper.Error("remove file err", err)
	}
}

func (d *RedisDbLogSender) Send(bytes []byte) error {
	if d.conn == nil {
		d.lock.Lock()
		defer d.lock.Unlock()
		address := gcore.NewAppSettingsHelper().GetAppConfig().DbSyncServerAddress
		if address == "" {
			return errors.New("DbSyncServerAddress is null")
		}
		conn, err := net.Dial("tcp", address)
		if err != nil {
			return err
		}
		d.conn = conn
	}

	head := dbUtils.SendHead{
		SendType:   2,
		ContentLen: uint32(len(bytes)),
	}
	headBytes, err := d.GetHeaderBytes(head)
	if err != nil {
		return err
	}
	_, err = d.conn.Write(headBytes)
	if err != nil {
		d.conn.Close()
		d.conn = nil
		return err
	}
	_, err = d.conn.Write(bytes)
	if err != nil {
		d.conn.Close()
		d.conn = nil
		return err
	}
	fmt.Println("send file bytes success")
	return nil
}

func (d *RedisDbLogSender) GetHeaderBytes(head dbUtils.SendHead) ([]byte, error) {
	var buf bytes.Buffer
	err := binary.Write(&buf, binary.BigEndian, uint32(head.SendType))
	if err != nil {
		return nil, err
	}
	err = binary.Write(&buf, binary.BigEndian, uint32(head.ContentLen))
	return buf.Bytes(), err
}