package db

import (
	"errors"
	"fmt"
	"github.com/aclindsa/moneygo/internal/models"
	"github.com/aclindsa/moneygo/internal/store"
	"math/big"
	"time"
)

// Split is a mirror of models.Split with the Amount broken out into whole and
// fractional components
type Split struct {
	SplitId         int64
	TransactionId   int64
	Status          int64
	ImportSplitType int64

	// One of AccountId and SecurityId must be -1
	// In normal splits, AccountId will be valid and SecurityId will be -1. The
	// only case where this is reversed is for transactions that have been
	// imported and not yet associated with an account.
	AccountId  int64
	SecurityId int64

	RemoteId string // unique ID from server, for detecting duplicates
	Number   string // Check or reference number
	Memo     string

	// Amount.Whole and Amount.Fractional(MaxPrecision)
	WholeAmount      int64
	FractionalAmount int64
}

func NewSplit(s *models.Split) (*Split, error) {
	whole, err := s.Amount.Whole()
	if err != nil {
		return nil, err
	}
	fractional, err := s.Amount.Fractional(MaxPrecision)
	if err != nil {
		return nil, err
	}
	return &Split{
		SplitId:          s.SplitId,
		TransactionId:    s.TransactionId,
		Status:           s.Status,
		ImportSplitType:  s.ImportSplitType,
		AccountId:        s.AccountId,
		SecurityId:       s.SecurityId,
		RemoteId:         s.RemoteId,
		Number:           s.Number,
		Memo:             s.Memo,
		WholeAmount:      whole,
		FractionalAmount: fractional,
	}, nil
}

func (s Split) Split() *models.Split {
	split := &models.Split{
		SplitId:         s.SplitId,
		TransactionId:   s.TransactionId,
		Status:          s.Status,
		ImportSplitType: s.ImportSplitType,
		AccountId:       s.AccountId,
		SecurityId:      s.SecurityId,
		RemoteId:        s.RemoteId,
		Number:          s.Number,
		Memo:            s.Memo,
	}
	split.Amount.FromParts(s.WholeAmount, s.FractionalAmount, MaxPrecision)

	return split
}

func (tx *Tx) incrementAccountVersions(user *models.User, accountids []int64) error {
	for i := range accountids {
		account, err := tx.GetAccount(accountids[i], user.UserId)
		if err != nil {
			return err
		}
		account.AccountVersion++
		count, err := tx.Update(account)
		if err != nil {
			return err
		}
		if count != 1 {
			return errors.New("Updated more than one account")
		}
	}
	return nil
}

func (tx *Tx) InsertTransaction(t *models.Transaction, user *models.User) error {
	// Map of any accounts with transaction splits being added
	a_map := make(map[int64]bool)
	for i := range t.Splits {
		if t.Splits[i].AccountId != -1 {
			existing, err := tx.SelectInt("SELECT count(*) from accounts where AccountId=?", t.Splits[i].AccountId)
			if err != nil {
				return err
			}
			if existing != 1 {
				return store.AccountMissingError{}
			}
			a_map[t.Splits[i].AccountId] = true
		} else if t.Splits[i].SecurityId == -1 {
			return store.AccountMissingError{}
		}
	}

	//increment versions for all accounts
	var a_ids []int64
	for id := range a_map {
		a_ids = append(a_ids, id)
	}
	// ensure at least one of the splits is associated with an actual account
	if len(a_ids) < 1 {
		return store.AccountMissingError{}
	}
	err := tx.incrementAccountVersions(user, a_ids)
	if err != nil {
		return err
	}

	t.UserId = user.UserId
	err = tx.Insert(t)
	if err != nil {
		return err
	}

	for i := range t.Splits {
		t.Splits[i].TransactionId = t.TransactionId
		t.Splits[i].SplitId = -1
		s, err := NewSplit(t.Splits[i])
		if err != nil {
			return err
		}
		err = tx.Insert(s)
		if err != nil {
			return err
		}
		*t.Splits[i] = *s.Split()
	}

	return nil
}

func (tx *Tx) SplitExists(s *models.Split) (bool, error) {
	count, err := tx.SelectInt("SELECT COUNT(*) from splits where RemoteId=? and AccountId=?", s.RemoteId, s.AccountId)
	return count == 1, err
}

func (tx *Tx) GetTransaction(transactionid int64, userid int64) (*models.Transaction, error) {
	var t models.Transaction
	var splits []*Split

	err := tx.SelectOne(&t, "SELECT * from transactions where UserId=? AND TransactionId=?", userid, transactionid)
	if err != nil {
		return nil, err
	}

	_, err = tx.Select(&splits, "SELECT * from splits where TransactionId=?", transactionid)
	if err != nil {
		return nil, err
	}

	for _, split := range splits {
		t.Splits = append(t.Splits, split.Split())
	}

	return &t, nil
}

func (tx *Tx) GetTransactions(userid int64) (*[]*models.Transaction, error) {
	var transactions []*models.Transaction

	_, err := tx.Select(&transactions, "SELECT * from transactions where UserId=?", userid)
	if err != nil {
		return nil, err
	}

	for i := range transactions {
		var splits []*Split
		_, err := tx.Select(&splits, "SELECT * from splits where TransactionId=?", transactions[i].TransactionId)
		if err != nil {
			return nil, err
		}
		for _, split := range splits {
			transactions[i].Splits = append(transactions[i].Splits, split.Split())
		}
	}

	return &transactions, nil
}

func (tx *Tx) UpdateTransaction(t *models.Transaction, user *models.User) error {
	var existing_splits []*Split

	_, err := tx.Select(&existing_splits, "SELECT * from splits where TransactionId=?", t.TransactionId)
	if err != nil {
		return err
	}

	// Map of any accounts with transaction splits being added
	a_map := make(map[int64]bool)

	// Make a map with any existing splits for this transaction
	s_map := make(map[int64]bool)
	for i := range existing_splits {
		s_map[existing_splits[i].SplitId] = true
	}

	// Insert splits, updating any pre-existing ones
	for i := range t.Splits {
		t.Splits[i].TransactionId = t.TransactionId
		s, err := NewSplit(t.Splits[i])
		if err != nil {
			return err
		}
		_, ok := s_map[s.SplitId]
		if ok {
			count, err := tx.Update(s)
			if err != nil {
				return err
			}
			if count > 1 {
				return fmt.Errorf("Updated %d transaction splits while attempting to update only 1", count)
			}
			delete(s_map, s.SplitId)
		} else {
			s.SplitId = -1
			err := tx.Insert(s)
			if err != nil {
				return err
			}
		}
		*t.Splits[i] = *s.Split()
		if t.Splits[i].AccountId != -1 {
			a_map[s.AccountId] = true
		}
	}

	// Delete any remaining pre-existing splits
	for i := range existing_splits {
		_, ok := s_map[existing_splits[i].SplitId]
		if existing_splits[i].AccountId != -1 {
			a_map[existing_splits[i].AccountId] = true
		}
		if ok {
			_, err := tx.Delete(existing_splits[i])
			if err != nil {
				return err
			}
		}
	}

	// Increment versions for all accounts with modified splits
	var a_ids []int64
	for id := range a_map {
		a_ids = append(a_ids, id)
	}
	err = tx.incrementAccountVersions(user, a_ids)
	if err != nil {
		return err
	}

	count, err := tx.Update(t)
	if err != nil {
		return err
	}
	if count > 1 {
		return fmt.Errorf("Updated %d transactions (expected 1)", count)
	}

	return nil
}

func (tx *Tx) DeleteTransaction(t *models.Transaction, user *models.User) error {
	var accountids []int64
	_, err := tx.Select(&accountids, "SELECT DISTINCT AccountId FROM splits WHERE TransactionId=? AND AccountId != -1", t.TransactionId)
	if err != nil {
		return err
	}

	_, err = tx.Exec("DELETE FROM splits WHERE TransactionId=?", t.TransactionId)
	if err != nil {
		return err
	}

	count, err := tx.Delete(t)
	if err != nil {
		return err
	}
	if count != 1 {
		return errors.New("Deleted more than one transaction")
	}

	err = tx.incrementAccountVersions(user, accountids)
	if err != nil {
		return err
	}

	return nil
}

func (tx *Tx) GetAccountSplits(user *models.User, accountid int64) (*[]*models.Split, error) {
	var modelsplits []*models.Split
	var splits []*Split

	sql := "SELECT DISTINCT splits.* FROM splits INNER JOIN transactions ON transactions.TransactionId = splits.TransactionId WHERE splits.AccountId=? AND transactions.UserId=?"
	_, err := tx.Select(&splits, sql, accountid, user.UserId)
	if err != nil {
		return nil, err
	}

	for _, s := range splits {
		modelsplits = append(modelsplits, s.Split())
	}
	return &modelsplits, nil
}

// Assumes accountid is valid and is owned by the current user
func (tx *Tx) GetAccountSplitsDate(user *models.User, accountid int64, date *time.Time) (*[]*models.Split, error) {
	var modelsplits []*models.Split
	var splits []*Split

	sql := "SELECT DISTINCT splits.* FROM splits INNER JOIN transactions ON transactions.TransactionId = splits.TransactionId WHERE splits.AccountId=? AND transactions.UserId=? AND transactions.Date < ?"
	_, err := tx.Select(&splits, sql, accountid, user.UserId, date)
	if err != nil {
		return nil, err
	}

	for _, s := range splits {
		modelsplits = append(modelsplits, s.Split())
	}
	return &modelsplits, nil
}

func (tx *Tx) GetAccountSplitsDateRange(user *models.User, accountid int64, begin, end *time.Time) (*[]*models.Split, error) {
	var modelsplits []*models.Split
	var splits []*Split

	sql := "SELECT DISTINCT splits.* FROM splits INNER JOIN transactions ON transactions.TransactionId = splits.TransactionId WHERE splits.AccountId=? AND transactions.UserId=? AND transactions.Date >= ? AND transactions.Date < ?"
	_, err := tx.Select(&splits, sql, accountid, user.UserId, begin, end)
	if err != nil {
		return nil, err
	}

	for _, s := range splits {
		modelsplits = append(modelsplits, s.Split())
	}
	return &modelsplits, nil
}

func (tx *Tx) transactionsBalanceDifference(accountid int64, transactions []*models.Transaction) (*big.Rat, error) {
	var pageDifference big.Rat
	for i := range transactions {
		var splits []*Split
		_, err := tx.Select(&splits, "SELECT * FROM splits where TransactionId=?", transactions[i].TransactionId)
		if err != nil {
			return nil, err
		}

		// Sum up the amounts from the splits we're returning so we can return
		// an ending balance
		for j, s := range splits {
			transactions[i].Splits = append(transactions[i].Splits, s.Split())
			if transactions[i].Splits[j].AccountId == accountid {
				pageDifference.Add(&pageDifference, &transactions[i].Splits[j].Amount.Rat)
			}
		}
	}
	return &pageDifference, nil
}

func (tx *Tx) GetAccountTransactions(user *models.User, accountid int64, sort string, page uint64, limit uint64) (*models.AccountTransactionsList, error) {
	var transactions []*models.Transaction
	var atl models.AccountTransactionsList

	var sqlsort, balanceLimitOffset string
	var balanceLimitOffsetArg uint64
	if sort == "date-asc" {
		sqlsort = " ORDER BY transactions.Date ASC, transactions.TransactionId ASC"
		balanceLimitOffset = " LIMIT ?"
		balanceLimitOffsetArg = page * limit
	} else if sort == "date-desc" {
		numSplits, err := tx.SelectInt("SELECT count(*) FROM splits")
		if err != nil {
			return nil, err
		}
		sqlsort = " ORDER BY transactions.Date DESC, transactions.TransactionId DESC"
		balanceLimitOffset = fmt.Sprintf(" LIMIT %d OFFSET ?", numSplits)
		balanceLimitOffsetArg = (page + 1) * limit
	}

	var sqloffset string
	if page > 0 {
		sqloffset = fmt.Sprintf(" OFFSET %d", page*limit)
	}

	account, err := tx.GetAccount(accountid, user.UserId)
	if err != nil {
		return nil, err
	}
	atl.Account = account

	sql := "SELECT DISTINCT transactions.* FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?" + sqlsort + " LIMIT ?" + sqloffset
	_, err = tx.Select(&transactions, sql, user.UserId, accountid, limit)
	if err != nil {
		return nil, err
	}
	atl.Transactions = &transactions

	pageDifference, err := tx.transactionsBalanceDifference(accountid, transactions)
	if err != nil {
		return nil, err
	}

	count, err := tx.SelectInt("SELECT count(DISTINCT transactions.TransactionId) FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?", user.UserId, accountid)
	if err != nil {
		return nil, err
	}
	atl.TotalTransactions = count

	security, err := tx.GetSecurity(atl.Account.SecurityId, user.UserId)
	if err != nil {
		return nil, err
	}
	if security == nil {
		return nil, errors.New("Security not found")
	}

	// Sum all the splits for all transaction splits for this account that
	// occurred before the page we're returning
	sql = "FROM splits AS s INNER JOIN (SELECT DISTINCT transactions.Date, transactions.TransactionId FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?" + sqlsort + balanceLimitOffset + ") as t ON s.TransactionId = t.TransactionId WHERE s.AccountId=?"
	count, err = tx.SelectInt("SELECT count(*) "+sql, user.UserId, accountid, balanceLimitOffsetArg, accountid)
	if err != nil {
		return nil, err
	}

	var balance models.Amount

	// Don't attempt to 'sum()' the splits if none exist, because it is
	// supposed to return null/nil in this case, which makes gorp angry since
	// we're using SelectInt()
	if count > 0 {
		whole, err := tx.SelectInt("SELECT sum(s.WholeAmount) "+sql, user.UserId, accountid, balanceLimitOffsetArg, accountid)
		if err != nil {
			return nil, err
		}
		fractional, err := tx.SelectInt("SELECT sum(s.FractionalAmount) "+sql, user.UserId, accountid, balanceLimitOffsetArg, accountid)
		if err != nil {
			return nil, err
		}
		balance.FromParts(whole, fractional, MaxPrecision)
	}

	atl.BeginningBalance = balance
	atl.EndingBalance.Rat.Add(&balance.Rat, pageDifference)

	return &atl, nil
}