package driver

import (
	"context"
	"database/sql"
	"fmt"
	"strings"
	"sync/atomic"
	"time"

	"github.com/ibuildthecloud/kvsql/pkg/broadcast"
	"github.com/pkg/errors"
	"github.com/sirupsen/logrus"
	utiltrace "k8s.io/apiserver/pkg/util/trace"
)

type Generic struct {
	// revision must be first to ensure that this is properly aligned for atomic.LoadInt64
	revision        int64

	db *sql.DB

	CleanupSQL      string
	GetSQL          string
	ListSQL         string
	ListRevisionSQL string
	ListResumeSQL   string
	ReplaySQL       string
	InsertSQL       string
	GetRevisionSQL  string
	ToDeleteSQL     string
	DeleteOldSQL    string

	changes     chan *KeyValue
	broadcaster broadcast.Broadcaster
	cancel      func()
}

func (g *Generic) Start(ctx context.Context, db *sql.DB) error {
	g.db = db
	g.changes = make(chan *KeyValue, 1024)

	row := db.QueryRowContext(ctx, g.GetRevisionSQL)
	rev := sql.NullInt64{}
	if err := row.Scan(&rev); err != nil {
		return errors.Wrap(err, "Failed to initialize revision")
	}
	if rev.Int64 == 0 {
		g.revision = 1
	} else {
		g.revision = rev.Int64
	}

	go func() {
		for {
			select {
			case <-ctx.Done():
				return
			case <-time.After(time.Minute):
				_, err := g.ExecContext(ctx, g.CleanupSQL, time.Now().Unix())
				if err != nil {
					logrus.Errorf("Failed to purge expired TTL entries")
				}

				err = g.cleanup(ctx)
				if err != nil {
					logrus.Errorf("Failed to cleanup duplicate entries")
				}
			}
		}
	}()

	return nil
}

func (g *Generic) cleanup(ctx context.Context) error {
	rows, err := g.QueryContext(ctx, g.ToDeleteSQL)
	if err != nil {
		return err
	}
	defer rows.Close()

	toDelete := map[string]int64{}
	for rows.Next() {
		var (
			count, revision int64
			name            string
		)
		err := rows.Scan(&count, &name, &revision)
		if err != nil {
			return err
		}
		toDelete[name] = revision
	}

	rows.Close()

	for name, rev := range toDelete {
		_, err = g.ExecContext(ctx, g.DeleteOldSQL, name, rev, rev)
		if err != nil {
			return err
		}
	}

	return nil
}

func (g *Generic) Get(ctx context.Context, key string) (*KeyValue, error) {
	kvs, _, err := g.List(ctx, 0, 1, key, "")
	if err != nil {
		return nil, err
	}
	if len(kvs) > 0 {
		return kvs[0], nil
	}
	return nil, nil
}

func (g *Generic) replayEvents(ctx context.Context, key string, revision int64) ([]*KeyValue, error) {
	rows, err := g.QueryContext(ctx, g.ReplaySQL, key, revision)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var resp []*KeyValue
	for rows.Next() {
		value := KeyValue{}
		if err := scan(rows.Scan, &value); err != nil {
			return nil, err
		}
		resp = append(resp, &value)
	}

	return resp, nil
}

func (g *Generic) List(ctx context.Context, revision, limit int64, rangeKey, startKey string) ([]*KeyValue, int64, error) {
	var (
		rows *sql.Rows
		err  error
	)

	if limit == 0 {
		limit = 1000000
	} else {
		limit = limit + 1
	}

	listRevision := atomic.LoadInt64(&g.revision)
	if !strings.HasSuffix(rangeKey, "%") && revision <= 0 {
		rows, err = g.QueryContext(ctx, g.GetSQL, rangeKey, 1)
	} else if revision <= 0 {
		rows, err = g.QueryContext(ctx, g.ListSQL, rangeKey, limit)
	} else if len(startKey) > 0 {
		listRevision = revision
		rows, err = g.QueryContext(ctx, g.ListResumeSQL, revision, rangeKey, startKey, limit)
	} else {
		rows, err = g.QueryContext(ctx, g.ListRevisionSQL, revision, rangeKey, limit)
	}

	if err != nil {
		return nil, 0, err
	}
	defer rows.Close()

	var resp []*KeyValue
	for rows.Next() {
		value := KeyValue{}
		if err := scan(rows.Scan, &value); err != nil {
			return nil, 0, err
		}
		if value.Revision > listRevision {
			listRevision = value.Revision
		}
		if value.Del == 0 {
			resp = append(resp, &value)
		}
	}

	return resp, listRevision, nil
}

func (g *Generic) Delete(ctx context.Context, key string, revision int64) ([]*KeyValue, error) {
	if strings.HasSuffix(key, "%") {
		panic("can not delete list revision")
	}

	_, err := g.mod(ctx, true, key, []byte{}, revision, 0)
	return nil, err
}

func (g *Generic) Update(ctx context.Context, key string, value []byte, revision, ttl int64) (*KeyValue, *KeyValue, error) {
	kv, err := g.mod(ctx, false, key, value, revision, ttl)
	if err != nil {
		return nil, nil, err
	}

	if kv.Version == 1 {
		return nil, kv, nil
	}

	oldKv := *kv
	oldKv.Revision = oldKv.OldRevision
	oldKv.Value = oldKv.OldValue
	return &oldKv, kv, nil
}

func (g *Generic) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
	trace := utiltrace.New(fmt.Sprintf("SQL DB ExecContext query: %s keys: %v", query, args))
	defer trace.LogIfLong(500 * time.Millisecond)

	return g.db.ExecContext(ctx, query, args...)
}

func (g *Generic) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
	trace := utiltrace.New(fmt.Sprintf("SQL DB QueryContext query: %s keys: %v", query, args))
	defer trace.LogIfLong(500 * time.Millisecond)

	return g.db.QueryContext(ctx, query, args...)
}

func (g *Generic) mod(ctx context.Context, delete bool, key string, value []byte, revision int64, ttl int64) (*KeyValue, error) {
	oldKv, err := g.Get(ctx, key)
	if err != nil {
		return nil, err
	}

	if revision > 0 && oldKv == nil {
		return nil, ErrNotExists
	}

	if revision > 0 && oldKv.Revision != revision {
		return nil, ErrRevisionMatch
	}

	if ttl > 0 {
		ttl = int64(time.Now().Unix()) + ttl
	}

	newRevision := atomic.AddInt64(&g.revision, 1)
	result := &KeyValue{
		Key:            key,
		Value:          value,
		Revision:       newRevision,
		TTL:            int64(ttl),
		CreateRevision: newRevision,
		Version:        1,
	}
	if oldKv != nil {
		result.OldRevision = oldKv.Revision
		result.OldValue = oldKv.Value
		result.TTL = oldKv.TTL
		result.CreateRevision = oldKv.CreateRevision
		result.Version = oldKv.Version + 1
	}

	if delete {
		result.Del = 1
	}

	_, err = g.ExecContext(ctx, g.InsertSQL,
		result.Key,
		result.Value,
		result.OldValue,
		result.OldRevision,
		result.CreateRevision,
		result.Revision,
		result.TTL,
		result.Version,
		result.Del,
	)
	if err != nil {
		return nil, err
	}

	g.changes <- result
	return result, nil
}

type scanner func(dest ...interface{}) error

func scan(s scanner, out *KeyValue) error {
	return s(
		&out.ID,
		&out.Key,
		&out.Value,
		&out.OldValue,
		&out.OldRevision,
		&out.CreateRevision,
		&out.Revision,
		&out.TTL,
		&out.Version,
		&out.Del)
}