package storage

import (
	"database/sql"
	"encoding/binary"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"math/bits"

	"git.sp4ke.com/sp4ke/bit4sat/db"
	"git.sp4ke.com/sp4ke/bit4sat/ln"
	"github.com/jmoiron/sqlx"
	"github.com/lib/pq"
	"github.com/mediocregopher/radix/v3"
)

var DB = db.DB

const (
	//TODO: sync upload status from redis
	// TODO: status is currently handled in cache not here
	DBUploadSchema = `
		CREATE TABLE IF NOT EXISTS upload (
			id serial PRIMARY KEY,
			upload_id varchar(9) NOT NULL,
			sha256 varchar(64) NOT NULL,
			file_name varchar(255) NOT NULL,
			file_type varchar(255) DEFAULT '',
			file_size integer NOT NULL,
			file_ext varchar(255) DEFAULT '',
			ask_fee integer NOT NULL DEFAULT 0,
			stored boolean DEFAULT '0',
			UNIQUE (upload_id, sha256)
		);
	`

	QNewUpload = `INSERT INTO upload
	(upload_id, sha256, file_name, file_type, file_size, file_ext, stored, ask_fee)
	VALUES
	(:upload_id, :sha256, :file_name, :file_type, :file_size, :file_ext, :stored, :ask_fee)`

	QSetStored = `UPDATE upload SET stored = :stored WHERE upload_id = :upload_id `

	QGetByHashID = `SELECT  upload_id,
							sha256,
							file_name,
							file_type,
							file_size,
							file_ext,
							ask_fee,
							stored
FROM upload WHERE sha256 = $1 AND upload_id = $2`
)

type UpStatus uint32

func (st UpStatus) MarshalJSON() ([]byte, error) {
	res := map[string]string{}
	res["pay_status"] = st.PrintPayStatus()
	res["store_status"] = st.PrintStoreStatus()

	return json.Marshal(res)
}

func (st *UpStatus) UnmarshalBinary(b []byte) error {
	//fmt.Printf("%#v\n", b)

	// first 4 bits are reseved
	// Single byte will be for 0 value
	if len(b) == 1 {
		*st = 0
		return nil
	}

	view := binary.BigEndian.Uint32(b)
	view = bits.Reverse32(view)
	//fmt.Printf("%32b\n", view)
	//log.Printf("%d\n", view)

	*st = UpStatus(view)

	return nil
}

// Get list of positions set
func (st UpStatus) GetFlagPositions() []int {
	var i uint32

	var setBits []int

	for i = 31; i > 0; i-- {
		if st&(1<<i) != 0 {
			setBits = append(setBits, int(i))
		}
	}

	return setBits
}

func (st UpStatus) PrintStoreStatus() string {
	if st.Stored() {
		return UploadStatus[UpStored]
	} else if st.StoreFail() {
		return UploadStatus[WaitStore]
	} else {
		return UploadStatus[WaitStore]
	}
}

func (st UpStatus) PrintPayStatus() string {
	if st.Paid() {
		return UploadStatus[UpPaid]
	}
	if st.Expired() {
		return UploadStatus[UpPayExpired]
	}

	return UploadStatus[WaitPay]
}

func (st UpStatus) IsNew() bool {
	return (st & UpNew) != 0
}

func (st UpStatus) WaitPay() bool {
	return (!st.Paid()) && (!st.Expired())
}

func (st UpStatus) Stored() bool {
	return (st & UpStored) != 0
}

func (st UpStatus) StoreFail() bool {
	return (st & UpStoreFail) != 0
}

func (st UpStatus) Paid() bool {
	return (st & UpPaid) != 0
}

func (st UpStatus) Expired() bool {
	return (st & UpPayExpired) != 0
}

func (st UpStatus) GetStoreStatus() UpStatus {
	return st & StoreMask
}

func (st UpStatus) GetPayStatus() UpStatus {
	return st & PayMask
}

// First 4 bits are reserved for easier parsing from redis
const (
	UpPayExpired UpStatus = 1 << (32 - 1 - iota)
	UpPaid

	UpStored // All files for this upload where stored
	UpStoreFail

	// Only used for printing
	WaitStore
	WaitPay

	UpNew = UpStatus(0)

	PayMask = UpPaid | UpPayExpired

	StoreMask = UpStored
)

var UploadStatus = map[UpStatus]string{
	UpNew: "new upload",

	// Payment
	UpPayExpired: "expired",
	UpPaid:       "paid",
	WaitPay:      "waiting",

	// Storage
	WaitStore: "waiting storage",
	UpStored:  "stored",
}

var (
	ErrDoesNotExist  = errors.New("does not exist")
	ErrAlreadyExists = errors.New("already exists")
)

type Upload struct {
	ID       string `db:"upload_id"`
	Free     bool   `db:"-"` // is this a free upload
	SHA256   string `db:"sha256"`
	FileName string `db:"file_name"`
	FileType string `db:"file_type"`
	FileSize int64  `db:"file_size"`
	FileExt  string `db:"file_ext"`
	Stored   bool   `db:"stored"`
	AskFee   int    `db:"ask_fee"` // fee asked for download
}

// TODO: sync from redis to db
//func SyncUploadStatusToDB(){

//}

func GetUploadInvoice(uploadId string) (*ln.Invoice, error) {
	invoice := ln.Invoice{}

	uploadInvoiceKey := fmt.Sprintf("upload_%s_invoice", uploadId)

	err := DB.Redis.Do(radix.FlatCmd(&invoice, "GET", uploadInvoiceKey))
	if err != nil {
		return nil, err
	}

	return &invoice, nil
}

func GetUploadInvoiceId(uploadId string) (string, error) {
	invoice, err := GetUploadInvoice(uploadId)

	return invoice.RHash, err
}

func SetUploadStatus(id string, status UpStatus) error {
	//log.Printf("setting upload status for %s", id)

	key := fmt.Sprintf("upload_status_%s", id)

	if status == UpNew {
		return DB.Redis.Do(radix.FlatCmd(nil, "SETBIT", key, 31, 0))
	}

	//log.Println("setting upload status for bit positions ", status.GetFlagPositions())
	// get bit positions

	for _, offset := range status.GetFlagPositions() {
		//log.Printf("setting bit at position %d", offset)
		err := DB.Redis.Do(radix.FlatCmd(nil,
			"SETBIT", key, offset, 1))
		if err != nil {
			return err
		}
	}

	log.Println("done set bit")

	return nil
}

func GetUploadStatus(id string) (status UpStatus, err error) {
	//log.Println("Getting upload status")

	key := fmt.Sprintf("upload_status_%s", id)

	err = DB.Redis.Do(radix.FlatCmd(&status, "GET", key))

	return
}

func SetUploadInvoice(uploadId string, invoice *ln.Invoice) error {
	uploadInvoiceKey := fmt.Sprintf("upload_%s_invoice", uploadId)

	invoiceJson, err := json.Marshal(invoice)
	if err != nil {
		return err
	}

	err = DB.Redis.Do(radix.FlatCmd(nil, "SET", uploadInvoiceKey, invoiceJson))
	if err != nil {
		return err
	}

	// Set inverse relation
	invoiceUploadKey := fmt.Sprintf("invoice_%s_upload", invoice.RHash)
	return DB.Redis.Do(radix.FlatCmd(nil, "SET", invoiceUploadKey, uploadId))
}

// Returns true if id exists in DB
func IdExists(id string) (exists bool, err error) {
	key := fmt.Sprintf("upload_status_%s", id)

	err = DB.Redis.Do(radix.Cmd(&exists, "EXISTS", key))
	return
}

// Get a file by upload id and hash
func GetByHashID(sha256 string, id string) (*Upload, error) {
	var up Upload

	err := DB.Sql.Get(&up, QGetByHashID, sha256, id)

	if err == sql.ErrNoRows {
		return nil, ErrDoesNotExist
	}

	if err != nil {
		return nil, err
	}

	return &up, nil
}

func (u *Upload) TxSetFileStored(tx *sqlx.Tx) error {
	u.Stored = true
	_, err := tx.NamedExec(QSetStored, u)

	if err != nil {
		return err
	}

	return nil
}

func (u *Upload) TxWrite(tx *sqlx.Tx) error {

	_, err := tx.NamedExec(QNewUpload, u)

	if pqError, ok := err.(*pq.Error); ok {
		// unique constraint
		if pqError.Code == "23505" {
			return ErrAlreadyExists
		}
	}

	if err != nil {
		return err
	}

	return nil
}

func (u *Upload) Write() error {
	_, err := DB.Sql.NamedExec(QNewUpload, u)

	if pqError, ok := err.(*pq.Error); ok {
		// unique constraint
		if pqError.Code == "23505" {
			return ErrAlreadyExists
		}
	}

	if err != nil {
		return err
	}

	return nil
}

func init() {
	_, err := DB.Sql.Exec(DBUploadSchema)
	if err != nil {
		log.Fatal(err)
	}
}