package models

import (
	"errors"
	"log"
	"smt/utils"
)

type Safe struct {
	SafeId   int    `db:"SafeId" json:"safeId"`
	SafeName string `db:"SafeName" json:"safeName"`
}

// SafeGetByName queries the database for the specified safe name
func SafeGetByName(safename string) (Safe, error) {
	var s Safe

	// Query database for matching group object
	err := db.QueryRowx("SELECT * FROM safes WHERE SafeName=?", safename).StructScan(&s)
	if err != nil {
		return s, errors.New("safe not found")
	}

	return s, nil
}

// SafeList returns a list of all safes in database
func SafeList() ([]Safe, error) {
	var results []Safe

	// Query database for safes
	rows, err := db.Queryx("SELECT * FROM safes")

	if err != nil {
		log.Printf("SafeList error executing sql record : '%s'\n", err)
		return results, err
	} else {
		// parse all the results into a slice
		for rows.Next() {
			var s Safe
			err = rows.StructScan(&s)
			if err != nil {
				log.Printf("SafeList error parsing sql record : '%s'\n", err)
				return results, err
			}
			results = append(results, s)

		}
		log.Printf("SafeList retrieved '%d' results\n", len(results))
	}

	return results, nil
}

// SafeList returns a list of safes in database that a user has access to
func SafeListAllowed(userId int) ([]Safe, error) {
	var results []Safe

	// Query database for safes
	rows, err := db.Queryx(`
		SELECT safes.* FROM safes INNER JOIN permissions ON safes.SafeId = permissions.SafeId INNER JOIN users ON users.GroupId = permissions.GroupId WHERE users.UserId = ?
		UNION
		SELECT safes.* FROM safes INNER JOIN permissions ON safes.SafeId = permissions.SafeId INNER JOIN users ON users.UserId = permissions.UserId WHERE users.UserId = ?
	`, userId, userId)

	if err != nil {
		log.Printf("SafeListAllowed error executing sql record : '%s'\n", err)
		return results, err
	} else {
		// parse all the results into a slice
		for rows.Next() {
			var s Safe
			err = rows.StructScan(&s)
			if err != nil {
				log.Printf("SafeListAllowed error parsing sql record : '%s'\n", err)
				return results, err
			}
			results = append(results, s)

			debugPrint := utils.PrintStructContents(&s, 0)
			log.Printf("SafeListAllowed adding record :\n%s\n", debugPrint)
		}
		log.Printf("SafeListAllowed retrieved '%d' results\n", len(results))
	}

	return results, nil
}

// SafeAdd adds a new safe definition to the database
func (s *Safe) SafeAdd() (*Safe, error) {
	var err error

	// Validate group not already in use
	_, err = SafeGetByName(s.SafeName)

	if err != nil && err.Error() == "safe not found" {
		log.Printf("SafeAdd confirmed no existing safe, continuing with creation of safe '%s'\n", s.SafeName)

		result, err := db.NamedExec(("INSERT INTO safes (SafeName) VALUES (:SafeName) RETURNING SafeId;"), s)

		//err = db.QueryRowx(`INSERT INTO users (user_id, user_nme, user_email, user_address_id) VALUES ($1, $2, $3, $4) RETURNING *;`, 6, fake.UserName(), fake.EmailAddress(), lastInsertId).StructScan(&user)

		if err != nil {
			log.Printf("SafeAdd error executing sql record : '%s'\n", err)
			return &Safe{}, err
		} else {
			affected, _ := result.RowsAffected()
			id, _ := result.LastInsertId()
			log.Printf("SafeAdd insert returned result id '%d' affecting %d row(s).\n", id, affected)
			s.SafeId = int(id)
			log.Printf("safe: %v\n", s)
		}
	} else {
		log.Printf("SafeAdd safe name already exists : '%v'\n", err)
	}

	return s, nil
}

// SafeDelete removes a safe definition from the database
func (s *Safe) SafeDelete() error {
	var err error

	// Validate group exists
	safe, err := SafeGetByName(s.SafeName)
	if err != nil && err.Error() == "safe not found" {
		log.Printf("SafeDelete unable to validate safe exists : '%s'\n", err)
		return err
	}

	// Make sure we have a safe ID
	if s.SafeId == 0 {
		s.SafeId = safe.SafeId
	}

	// Delete the safe
	log.Printf("SafeDelete confirmed safe exists, continuing with deletion of safe '%s'\n", s.SafeName)
	result, err := db.NamedExec((`DELETE FROM safes WHERE SafeId = :SafeId`), s)

	if err != nil {
		log.Printf("SafeDelete error executing sql delete : '%s'\n", err)
		return err
	} else {
		affected, _ := result.RowsAffected()
		id, _ := result.LastInsertId()
		log.Printf("SafeDelete returned result id '%d' affecting %d row(s).\n", id, affected)
	}

	return nil
}