package main

import (
	"fmt"
	"github.com/jinzhu/gorm"
	"log"
	"time"
)

type TaskStatus int
type ProcessStatus int

type UploadTask struct {
	ID int `json:"id" gorm:"column:id;primary_key"`

	SecondID *string `json:"secondId" gorm:"column:second_id;unique_index:second_id"`

	Ctx       string `json:"ctx" gorm:"ctx"`
	CallID    string `json:"callId" gorm:"column:call_id;index:call_id"`
	ConfID    string `json:"confId" gorm:"column:conf_id"`
	RoomID    string `json:"roomId" gorm:"column:room_id"`
	FromEID   string `json:"fromEid" gorm:"column:from_eid"`
	ServiceID string `json:"serviceId" gorm:"column:service_id"`

	CreatedAt time.Time `json:"createdAt" gorm:"column:created_at"`
	UpdatedAt time.Time `json:"updatedAt" gorm:"column:updated_at"`

	Status     TaskStatus    `json:"status" gorm:"column:status;index:status"`
	Processing ProcessStatus `json:"processing" grom:"column:processing;index:processing"`

	Type           string `json:"type" gorm:"column:type;index:type"`
	AppVersion     string `json:"appVersion" gorm:"column:app_version"`
	InputFiles     string `json:"inputFiles" gorm:"column:input_files"`
	TargetFile     string `json:"targetFile" gorm:"column:target_file"`
	CustomData     string `json:"customData" gorm:"column:custom_data"`
	InternalData   string `json:"internalData" gorm:"column:internal_data"`
	CancelReason   string `json:"cancelReason" gorm:"column:cancel_reason"`
	RetryCount     int    `json:"retryCount" gorm:"column:retry_count"`
	InitRetryCount int    `json:"initRetryCount" gorm:"column:init_retry_count"`
	STTRetryCount  int    `json:"sttRetryCount" gorm:"column:stt_retry_count"`

	FromVisitorRealm bool `json:"fromVisitorRealm" gorm:"column:from_visitor_realm"`
}

type Version struct {
	gorm.Model
	Version int    `gorm:"column:version"` // ; primaryKey
	Comment string `gorm:"column:comment"`
}

type VersionTask func(db *gorm.DB) error

func insertVersion(db *gorm.DB, version int, comment string) error {
	tag := "[insertVersion]"
	// update version
	var verInfo Version
	verInfo.Version = 1
	verInfo.Comment = comment
	if err := db.Debug().Create(&verInfo).Error; err != nil {
		fmt.Printf("%s %v", tag, err)
		return err
	}
	fmt.Printf("%s now version is %d", tag, verInfo.Version)
	// db.Model(&verInfo).Update(verInfo)
	return nil
}

func taskForVersion1(db *gorm.DB) error {
	fmt.Println("[taskForVersion1] Executing task for version 1")
	db.Debug().Model(&UploadTask{}).Update("init_retry_count", 15)
	db.Debug().Model(&UploadTask{}).Update("stt_retry_count", 0)
	err := insertVersion(db, 1, fmt.Sprintf("updated to version %d", 1))
	if err != nil {
		return err
	}
	return nil
}

func taskForVersion2(db *gorm.DB) error {
	fmt.Println("[taskForVersion2] Executing task for version 2")
	return nil
}

func taskForVersion3(db *gorm.DB) error {
	fmt.Println("Executing task for version 3")
	return nil
}

func main() {

	latestDBVersion := 1
	var versionTasks = []VersionTask{
		nil,
		taskForVersion1,
		taskForVersion2,
		taskForVersion3,
	}

	// open db
	db, err := gorm.Open("sqlite3", "cru_test.db")
	if err != nil {
		panic("Can't connect")
	}
	defer db.Close()

	// migrate
	db.Debug().AutoMigrate(&UploadTask{}, &Version{})

	// check version
	var currVerInfo Version
	//if err := db.Debug().Last(&verInfo).Order("version DESC").Error; err != nil {
	if err := db.Debug().Raw("SELECT * FROM versions order by version desc LIMIT 1").Scan(&currVerInfo).Error; err != nil {
		if gorm.IsRecordNotFoundError(err) {
			fmt.Println("No any row in table 'versions'. Prepare to create.")
			currVerInfo = Version{Version: 0, Comment: "Initial version"}
			db.Debug().Create(&currVerInfo)
		} else {
			fmt.Println("Query Table[Version] Error.")
		}
	}

	fmt.Println("[Info] Current version:", currVerInfo.Version)

	for i := currVerInfo.Version + 1; i <= latestDBVersion; i++ {
		if i < len(versionTasks) {
			fmt.Printf("[Info] Processing version function %d\n", i)
			err := versionTasks[i](db)
			if err != nil {
				log.Println(err.Error())
			}
		} else {
			fmt.Printf("No task defined for version %d\n", i)
		}
	}

}