package syncdb

import (
	"errors"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"sync"
	"github.com/jinzhu/gorm"
)

const (
	PersonSqliteDBPath = "~/workspace/gitblit/dbserver/config/testdb.db"
)

var syncMut sync.Mutex
var SerfDbConn *Conn

// get Conn of db for do execute.
func InitDbConn(dbPath string) error {

	if dbPath == "" {
		dbPath = PersonSqliteDBPath
	}

	fmt.Println("self: ========>", dbPath)
	db, err := New(dbPath, "", false)
	if err != nil {
		fmt.Println("new db database: ", err)
		return err
	}
	dbConn, err := db.Connect()
	if err != nil {
		fmt.Println("new db conn error; ", err)
		return err
	}

	SerfDbConn = dbConn
	return nil
}

//bak dbdata.
func BakDbFile() (string, error) {

	path, err := getCurrentPath()
	if err != nil {
		fmt.Println("getCurrentPath error; ", err)
		return "", err
	}

	filepath := path + "tmp.db"
	fmt.Println("filepath:", filepath)
	db, err := New(filepath, "", false)
	if err != nil {
		fmt.Println("new db database: ", err)
		return "", err
	}

	tmpconn, err := db.Connect()
	if err != nil {
		fmt.Println("new db conn error; ", err)
		return "", err
	}
	defer tmpconn.Close()

	err = SerfDbConn.Backup(tmpconn)
	if err != nil {
		return "", err
	}
	return filepath, nil
}

// do exet when get querystring.
func ExecuteWriteSql(sqlString []string) ([]*Result, error) {
	syncMut.Lock()
	defer syncMut.Unlock()
	allResults, err := SerfDbConn.Execute(sqlString, false, false)
	if err != nil {
		fmt.Println("execute error!", err)
		return nil, err
	}
	return allResults, nil
}

var localDb *gorm.DB
func InitLocalDb(db *gorm.DB) {
	localDb = db
}

// do exet when get querystring.
func ExecuteQuerySql(sqlString []string) ([]*Rows, error) {
	syncMut.Lock()
	defer syncMut.Unlock()
	rows, err := SerfDbConn.Query(sqlString, false, false)
	if err != nil {
		fmt.Println("execute error!", err)
		return nil, err
	}
	return rows, nil
}

func ExecuteSqlByGorm(sqls []string) (bool,error) {
	if localDb != nil {
		localDb.LogMode(false)
		defer localDb.LogMode(true)
		var err error
		tx := localDb.Begin()
		defer func() {
			if err !=nil && tx !=nil {
				tx.Rollback()
			}
		}()
		for _,sql :=range sqls {
			result := tx.Exec(sql)
			if result.Error !=nil {
				return false,result.Error
			}
			if result.RowsAffected == 0{
				fmt.Println("ExecuteSqlByGorm fail")
				return false,errors.New("ExecuteSqlByGorm fail")
			}
		}
		tx.Commit()
		return true,nil
	}
	return false,errors.New("localDb is nil")
}

type TableDesc struct {
	Cid int `json:"cid"`
	Name string `json:"name"`
	Type string `json:"type"`
	Notnull bool `json:"notnull"`
	DFltValue interface{} `json:"dflt_value"`
	Pk int `json:"pk"`
}

type DumpSql struct {
	Sql string `json:"sql"`
}

func ExecuteQueryByGorm(tableNames []string) ([]string, error) {
	localDb.LogMode(false)
	defer localDb.LogMode(true)
	if tableNames !=nil {
		var arr []string
		var dumpSql []DumpSql
		for _,table :=range tableNames {
			dumpSql = make([]DumpSql, 0)
			var tDescArr []TableDesc
			tSql := fmt.Sprintf(`PRAGMA table_info("%s")`, table)
			err := localDb.Raw(tSql).Scan(&tDescArr).Error
			if err !=nil {
				return nil,errors.New("tableDesc err")
			}
			fmt.Println(table,"'Columns is:",tDescArr)
			if tDescArr == nil || len(tDescArr) == 0 {
				return nil,errors.New(table+" has no column")
			}
			var columnNames []string
			for _,col :=range tDescArr {
				columnNames = append(columnNames, fmt.Sprintf(`'||quote("%s")||'`, col.Name))
			}
			tSql = fmt.Sprintf(`SELECT 'INSERT INTO "%s" VALUES(%s)' as sql FROM "%s";`,
				table,
				strings.Join(columnNames, ","),
				table)
			fmt.Println("tSql:",tSql)

			err = localDb.Raw(tSql).Scan(&dumpSql).Error
			if err !=nil {
				return nil,errors.New("dump err")
				continue
			}
			if len(dumpSql)>0 {
				for _,d :=range dumpSql {
					arr = append(arr, d.Sql)
				}
			}

		}
		return arr,nil
	}
	return nil,errors.New("tableNames is nil")
}

func Dumpdb() {

	var b strings.Builder
	if err := SerfDbConn.Dump(&b); err != nil {
		fmt.Println("dump file ", err.Error())
	}
	fmt.Printf("%T\n", b)
}

// get current path
func getCurrentPath() (string, error) {
	file, err := exec.LookPath(os.Args[0])
	if err != nil {
		return "", err
	}
	path, err := filepath.Abs(file)
	if err != nil {
		return "", err
	}
	i := strings.LastIndex(path, "/")
	if i < 0 {
		i = strings.LastIndex(path, "\\")
	}
	if i < 0 {
		return "", errors.New(`error: Can't find "/" or "\".`)
	}
	return string(path[0 : i+1]), nil
}