package main

import (
	"crypto/rand"
	"crypto/sha256"
	"database/sql"
	"encoding/hex"
	"errors"
	"fmt"
	"regexp"
	"strings"
	"time"

	"golang.org/x/crypto/bcrypt"
	"golang.org/x/crypto/ssh"
	_ "modernc.org/sqlite"
)

const schema = `
create table if not exists users (
	id integer primary key,
	name text not null unique,
	hash text not null,
	created integer not null
);
create table if not exists sessions (
	id text primary key,
	user integer not null references users(id) on delete cascade,
	created integer not null
);
create table if not exists keys (
	id integer primary key,
	user integer not null references users(id) on delete cascade,
	fingerprint text not null unique,
	public text not null,
	title text not null,
	created integer not null
);
create table if not exists tokens (
	id integer primary key,
	user integer not null references users(id) on delete cascade,
	hash text not null unique,
	title text not null,
	created integer not null
);
create table if not exists repos (
	id integer primary key,
	owner integer not null references users(id) on delete cascade,
	name text not null,
	description text not null default '',
	private integer not null default 0,
	created integer not null,
	unique(owner, name)
);
create table if not exists invites (
	code text primary key,
	used integer not null default 0
);
`

var migrations = []string{
	`alter table users add column bio text not null default ''`,
	`alter table users add column location text not null default ''`,
	`alter table users add column workplace text not null default ''`,
	`alter table users add column website text not null default ''`,
	`alter table users add column avatar integer not null default 0`,
	`alter table users add column display text not null default ''`,
	`alter table repos add column tags text not null default ''`,
	`alter table repos add column parent integer not null default 0`,
	`alter table repos add column archived integer not null default 0`,
	`alter table users add column email text not null default ''`,
	`alter table users add column verified integer not null default 0`,
	`alter table users add column notify integer not null default 1`,
	`alter table users add column banned integer not null default 0`,
	`alter table users add column totp text not null default ''`,
	`alter table users add column recovery text not null default ''`,
	`alter table pulls add column draft integer not null default 0`,
	`alter table repos add column featured integer not null default 0`,
}

const extraSchema = `
create table if not exists mailtokens (
	token text primary key,
	user integer not null references users(id) on delete cascade,
	kind text not null,
	email text not null,
	created integer not null
);
create table if not exists stars (
	user integer not null references users(id) on delete cascade,
	repo integer not null references repos(id) on delete cascade,
	created integer not null,
	primary key(user, repo)
);
create table if not exists issues (
	id integer primary key,
	repo integer not null references repos(id) on delete cascade,
	number integer not null,
	author integer not null references users(id) on delete cascade,
	title text not null,
	body text not null default '',
	state text not null default 'open',
	created integer not null,
	updated integer not null,
	unique(repo, number)
);
create table if not exists labels (
	id integer primary key,
	repo integer not null references repos(id) on delete cascade,
	name text not null,
	colour text not null default '#6c757d',
	unique(repo, name)
);
create table if not exists labelled (
	kind text not null,
	item integer not null,
	label integer not null references labels(id) on delete cascade,
	primary key(kind, item, label)
);
create table if not exists assigned (
	kind text not null,
	item integer not null,
	user integer not null references users(id) on delete cascade,
	primary key(kind, item, user)
);
create table if not exists protected (
	repo integer not null references repos(id) on delete cascade,
	branch text not null,
	require_pr integer not null default 0,
	approvals integer not null default 0,
	primary key(repo, branch)
);
create table if not exists prreviews (
	id integer primary key,
	pull integer not null references pulls(id) on delete cascade,
	author integer not null references users(id) on delete cascade,
	state text not null,
	body text not null default '',
	head text not null default '',
	created integer not null
);
create table if not exists issue_comments (
	id integer primary key,
	issue integer not null references issues(id) on delete cascade,
	author integer not null references users(id) on delete cascade,
	body text not null,
	created integer not null
);
`

const collabSchema = `
create table if not exists collaborators (
	repo integer not null references repos(id) on delete cascade,
	user integer not null references users(id) on delete cascade,
	created integer not null,
	primary key(repo, user)
);
create table if not exists pgp (
	id integer primary key,
	user integer not null references users(id) on delete cascade,
	fingerprint text not null unique,
	armored text not null,
	created integer not null
);
`

const (
	Public   = 0
	Private  = 1
	Unlisted = 2
)

type Profile struct {
	Display   string
	Bio       string
	Location  string
	Workplace string
	Website   string
	Avatar    int64
}

var nameRe = regexp.MustCompile(`^[a-z0-9][a-z0-9_.-]{0,38}$`)

var ErrNotFound = errors.New("not found")

type User struct {
	ID      int64
	Name    string
	Created time.Time
}

type Repo struct {
	ID          int64
	Owner       User
	Name        string
	Description string
	Private     bool
	Unlisted    bool
	Tags        []string
	Parent      int64
	Archived    bool
	Stars       int
	Created     time.Time
	Updated     time.Time
}

var tagRe = regexp.MustCompile(`^[a-z0-9][a-z0-9+.-]{0,23}$`)

func parseTags(raw string) ([]string, error) {
	var tags []string
	for _, t := range strings.Split(raw, ",") {
		t = strings.ToLower(strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(t), "#")))
		if t == "" {
			continue
		}
		if !tagRe.MatchString(t) {
			return nil, errors.New("Tags are lowercase letters, digits, dot, plus or dash, at most 24 characters")
		}
		tags = append(tags, t)
	}
	if len(tags) > 3 {
		return nil, errors.New("Up to three tags")
	}
	return tags, nil
}

func splitTags(raw string) []string {
	if raw == "" {
		return nil
	}
	return strings.Split(raw, ",")
}

type Key struct {
	ID          int64
	Fingerprint string
	Public      string
	Title       string
	Created     time.Time
}

type Token struct {
	ID      int64
	Title   string
	Created time.Time
}

type Store struct {
	db *sql.DB
}

func openStore(path string, readonly bool) (*Store, error) {
	dsn := "file:" + path + "?_pragma=busy_timeout(5000)&_pragma=journal_mode(wal)&_pragma=foreign_keys(1)"
	if readonly {
		dsn += "&mode=ro"
	}
	db, err := sql.Open("sqlite", dsn)
	if err != nil {
		return nil, err
	}
	if !readonly {
		if _, err := db.Exec(schema); err != nil {
			return nil, err
		}
		for _, m := range migrations {
			if _, err := db.Exec(m); err != nil && !strings.Contains(err.Error(), "duplicate column") {
				return nil, err
			}
		}
		if _, err := db.Exec(pullSchema); err != nil {
			return nil, err
		}
		if _, err := db.Exec(collabSchema); err != nil {
			return nil, err
		}
		if _, err := db.Exec(extraSchema); err != nil {
			return nil, err
		}
	}
	return &Store{db}, nil
}

func random(n int) string {
	b := make([]byte, n)
	if _, err := rand.Read(b); err != nil {
		panic(err)
	}
	return hex.EncodeToString(b)
}

func validName(name string) bool {
	return nameRe.MatchString(name) && !strings.HasSuffix(name, ".git")
}

func checkCredentials(name, password string) error {
	if !validName(name) {
		return errors.New("Names are lowercase letters, digits, dot, dash or underscore, at most 39 characters")
	}
	if len(password) < 8 {
		return errors.New("Password must be at least 8 characters")
	}
	if len(password) > 256 {
		return errors.New("Password must be at most 256 characters")
	}
	return nil
}

func (s *Store) CreateUser(name, password string) (User, error) {
	if err := checkCredentials(name, password); err != nil {
		return User{}, err
	}
	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		return User{}, err
	}
	now := time.Now()
	res, err := s.db.Exec(`insert into users(name, hash, created) values (?, ?, ?)`, name, string(hash), now.Unix())
	if err != nil {
		if strings.Contains(err.Error(), "UNIQUE") {
			return User{}, errors.New("That name is taken")
		}
		return User{}, err
	}
	id, _ := res.LastInsertId()
	return User{ID: id, Name: name, Created: now}, nil
}

func (s *Store) UserByName(name string) (User, error) {
	var u User
	var created int64
	err := s.db.QueryRow(`select id, name, created from users where name = ?`, name).Scan(&u.ID, &u.Name, &created)
	if err == sql.ErrNoRows {
		return u, ErrNotFound
	}
	u.Created = time.Unix(created, 0)
	return u, err
}

func (s *Store) userByID(id int64) (User, error) {
	var u User
	var created int64
	err := s.db.QueryRow(`select id, name, created from users where id = ?`, id).Scan(&u.ID, &u.Name, &created)
	if err == sql.ErrNoRows {
		return u, ErrNotFound
	}
	u.Created = time.Unix(created, 0)
	return u, err
}

func (s *Store) CheckPassword(name, password string) (User, bool) {
	var u User
	var hash string
	var created int64
	err := s.db.QueryRow(`select id, name, hash, created from users where name = ? and banned = 0`, name).Scan(&u.ID, &u.Name, &hash, &created)
	if err != nil {
		bcrypt.CompareHashAndPassword([]byte("$2a$10$000000000000000000000uGJ8z1gQ7yP1cqeI4qzj6WmLIl3JcP6W"), []byte(password))
		return u, false
	}
	u.Created = time.Unix(created, 0)
	return u, bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)) == nil
}

func (s *Store) SetPassword(user int64, password string) error {
	if err := checkCredentials("x", password); err != nil {
		return err
	}
	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		return err
	}
	_, err = s.db.Exec(`update users set hash = ? where id = ?`, string(hash), user)
	return err
}

func (s *Store) CreateSession(user int64) (string, error) {
	id := random(32)
	_, err := s.db.Exec(`insert into sessions(id, user, created) values (?, ?, ?)`, id, user, time.Now().Unix())
	return id, err
}

func (s *Store) SessionUser(id string) (User, error) {
	var user int64
	err := s.db.QueryRow(`select s.user from sessions s join users u on u.id = s.user where s.id = ? and s.created > ? and u.banned = 0`, id, time.Now().Add(-90*24*time.Hour).Unix()).Scan(&user)
	if err != nil {
		return User{}, ErrNotFound
	}
	return s.userByID(user)
}

func (s *Store) DeleteSession(id string) {
	s.db.Exec(`delete from sessions where id = ?`, id)
}

func (s *Store) DeleteSessions(user int64) {
	s.db.Exec(`delete from sessions where user = ?`, user)
}

func (s *Store) AddKey(user int64, title, public string) error {
	pub, comment, _, _, err := ssh.ParseAuthorizedKey([]byte(public))
	if err != nil {
		return errors.New("That is not a valid OpenSSH public key")
	}
	if title == "" {
		title = comment
	}
	if title == "" {
		title = "key"
	}
	line := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))
	_, err = s.db.Exec(`insert into keys(user, fingerprint, public, title, created) values (?, ?, ?, ?, ?)`,
		user, ssh.FingerprintSHA256(pub), line, title, time.Now().Unix())
	if err != nil && strings.Contains(err.Error(), "UNIQUE") {
		return errors.New("That key is already registered")
	}
	return err
}

func (s *Store) Keys(user int64) ([]Key, error) {
	rows, err := s.db.Query(`select id, fingerprint, public, title, created from keys where user = ? order by id`, user)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var keys []Key
	for rows.Next() {
		var k Key
		var created int64
		if err := rows.Scan(&k.ID, &k.Fingerprint, &k.Public, &k.Title, &created); err != nil {
			return nil, err
		}
		k.Created = time.Unix(created, 0)
		keys = append(keys, k)
	}
	return keys, rows.Err()
}

func (s *Store) DeleteKey(user, id int64) error {
	_, err := s.db.Exec(`delete from keys where user = ? and id = ?`, user, id)
	return err
}

func (s *Store) UserByFingerprint(fp string) (User, bool) {
	var user int64
	if err := s.db.QueryRow(`select user from keys where fingerprint = ?`, fp).Scan(&user); err != nil {
		return User{}, false
	}
	u, err := s.userByID(user)
	return u, err == nil
}

func (s *Store) AllKeys() ([]string, error) {
	rows, err := s.db.Query(`select public from keys order by id`)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var keys []string
	for rows.Next() {
		var k string
		if err := rows.Scan(&k); err != nil {
			return nil, err
		}
		keys = append(keys, k)
	}
	return keys, rows.Err()
}

func (s *Store) UserByKey(public string) (User, error) {
	pub, _, _, _, err := ssh.ParseAuthorizedKey([]byte(public))
	if err != nil {
		return User{}, err
	}
	var user int64
	err = s.db.QueryRow(`select k.user from keys k join users u on u.id = k.user where k.fingerprint = ? and u.banned = 0`, ssh.FingerprintSHA256(pub)).Scan(&user)
	if err != nil {
		return User{}, ErrNotFound
	}
	return s.userByID(user)
}

func tokenHash(token string) string {
	sum := sha256.Sum256([]byte(token))
	return hex.EncodeToString(sum[:])
}

func (s *Store) CreateToken(user int64, title string) (string, error) {
	if title == "" {
		title = "token"
	}
	token := random(24)
	_, err := s.db.Exec(`insert into tokens(user, hash, title, created) values (?, ?, ?, ?)`, user, tokenHash(token), title, time.Now().Unix())
	return token, err
}

func (s *Store) Tokens(user int64) ([]Token, error) {
	rows, err := s.db.Query(`select id, title, created from tokens where user = ? order by id`, user)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var tokens []Token
	for rows.Next() {
		var t Token
		var created int64
		if err := rows.Scan(&t.ID, &t.Title, &created); err != nil {
			return nil, err
		}
		t.Created = time.Unix(created, 0)
		tokens = append(tokens, t)
	}
	return tokens, rows.Err()
}

func (s *Store) DeleteToken(user, id int64) error {
	_, err := s.db.Exec(`delete from tokens where user = ? and id = ?`, user, id)
	return err
}

func (s *Store) UserByToken(name, token string) (User, bool) {
	var user int64
	err := s.db.QueryRow(`select t.user from tokens t join users u on u.id = t.user where u.name = ? and t.hash = ? and u.banned = 0`, name, tokenHash(token)).Scan(&user)
	if err != nil {
		return User{}, false
	}
	u, err := s.userByID(user)
	return u, err == nil
}

func (s *Store) CreateRepo(owner User, name, description string, visibility int, rawTags string) (Repo, error) {
	if !validName(name) || name == "avatar" || name == "stars" || name == "feed" {
		return Repo{}, errors.New("Repository names are lowercase letters, digits, dot, dash or underscore")
	}
	tags, err := parseTags(rawTags)
	if err != nil {
		return Repo{}, err
	}
	now := time.Now()
	res, err := s.db.Exec(`insert into repos(owner, name, description, private, tags, created) values (?, ?, ?, ?, ?, ?)`,
		owner.ID, name, description, visibility, strings.Join(tags, ","), now.Unix())
	if err != nil {
		if strings.Contains(err.Error(), "UNIQUE") {
			return Repo{}, errors.New("You already have a repository with that name")
		}
		return Repo{}, err
	}
	id, _ := res.LastInsertId()
	return Repo{ID: id, Owner: owner, Name: name, Description: description, Private: visibility == Private, Unlisted: visibility == Unlisted, Tags: tags, Created: now}, nil
}

func scanRepos(rows *sql.Rows) ([]Repo, error) {
	defer rows.Close()
	var repos []Repo
	for rows.Next() {
		var r Repo
		var private, archived int
		var tags string
		var created, ucreated int64
		if err := rows.Scan(&r.ID, &r.Name, &r.Description, &private, &tags, &r.Parent, &archived, &r.Stars, &created, &r.Owner.ID, &r.Owner.Name, &ucreated); err != nil {
			return nil, err
		}
		r.Archived = archived != 0
		r.Private = private == Private
		r.Unlisted = private == Unlisted
		r.Tags = splitTags(tags)
		r.Created = time.Unix(created, 0)
		r.Owner.Created = time.Unix(ucreated, 0)
		repos = append(repos, r)
	}
	return repos, rows.Err()
}

const repoColumns = `r.id, r.name, r.description, r.private, r.tags, r.parent, r.archived, (select count(*) from stars st where st.repo = r.id), r.created, u.id, u.name, u.created from repos r join users u on u.id = r.owner`

func (s *Store) Backup(path string) error {
	_, err := s.db.Exec(`vacuum into ?`, path)
	return err
}

func (s *Store) FeaturedRepos() ([]Repo, error) {
	rows, err := s.db.Query(`select ` + repoColumns + ` where r.private = 0 and r.featured > 0 order by r.featured`)
	if err != nil {
		return nil, err
	}
	return scanRepos(rows)
}

func (s *Store) SetFeatured(owner, name string, rank int) error {
	res, err := s.db.Exec(`update repos set featured = ? where name = ? and owner = (select id from users where name = ?)`, rank, name, owner)
	if err != nil {
		return err
	}
	if n, _ := res.RowsAffected(); n == 0 {
		return ErrNotFound
	}
	return nil
}

func (s *Store) RepoByID(id int64) (Repo, error) {
	rows, err := s.db.Query(`select `+repoColumns+` where r.id = ?`, id)
	if err != nil {
		return Repo{}, err
	}
	repos, err := scanRepos(rows)
	if err != nil || len(repos) == 0 {
		return Repo{}, ErrNotFound
	}
	return repos[0], nil
}

func (s *Store) RepoByPath(owner, name string) (Repo, error) {
	rows, err := s.db.Query(`select `+repoColumns+` where u.name = ? and r.name = ?`, owner, name)
	if err != nil {
		return Repo{}, err
	}
	repos, err := scanRepos(rows)
	if err != nil {
		return Repo{}, err
	}
	if len(repos) == 0 {
		return Repo{}, ErrNotFound
	}
	return repos[0], nil
}

func (s *Store) ReposByOwner(owner int64, includePrivate bool) ([]Repo, error) {
	rows, err := s.db.Query(`select `+repoColumns+` where r.owner = ? and (r.private = 0 or ?) order by r.name`, owner, includePrivate)
	if err != nil {
		return nil, err
	}
	return scanRepos(rows)
}

func (s *Store) UpdateRepo(id int64, description string, visibility int, rawTags string) error {
	tags, err := parseTags(rawTags)
	if err != nil {
		return err
	}
	_, err = s.db.Exec(`update repos set description = ?, private = ?, tags = ? where id = ?`, description, visibility, strings.Join(tags, ","), id)
	return err
}

func (s *Store) PublicRepos(query, tag string) ([]Repo, error) {
	like := "%" + strings.ReplaceAll(strings.ReplaceAll(query, "%", ""), "_", "") + "%"
	rows, err := s.db.Query(`select `+repoColumns+` where r.private = 0 and (? = '' or r.name like ? or r.description like ? or u.name like ? or r.tags like ?) and (? = '' or ',' || r.tags || ',' like ?) order by r.created desc limit 500`,
		query, like, like, like, like, tag, "%,"+tag+",%")
	if err != nil {
		return nil, err
	}
	return scanRepos(rows)
}

func (s *Store) DeleteRepo(id int64) error {
	_, err := s.db.Exec(`delete from repos where id = ?`, id)
	return err
}

func (s *Store) Profile(user int64) Profile {
	var p Profile
	s.db.QueryRow(`select display, bio, location, workplace, website, avatar from users where id = ?`, user).Scan(&p.Display, &p.Bio, &p.Location, &p.Workplace, &p.Website, &p.Avatar)
	return p
}

func (s *Store) UpdateProfile(user int64, p Profile) error {
	if p.Website != "" && !strings.HasPrefix(p.Website, "https://") && !strings.HasPrefix(p.Website, "http://") {
		p.Website = "https://" + p.Website
	}
	_, err := s.db.Exec(`update users set display = ?, bio = ?, location = ?, workplace = ?, website = ? where id = ?`, p.Display, p.Bio, p.Location, p.Workplace, p.Website, user)
	return err
}

func (s *Store) SetAvatar(user int64, version int64) error {
	_, err := s.db.Exec(`update users set avatar = ? where id = ?`, version, user)
	return err
}

func (s *Store) AddCollaborator(repo int64, name string) error {
	u, err := s.UserByName(name)
	if err != nil {
		return errors.New("No such user")
	}
	_, err = s.db.Exec(`insert or ignore into collaborators(repo, user, created) values (?, ?, ?)`, repo, u.ID, time.Now().Unix())
	return err
}

func (s *Store) RemoveCollaborator(repo, user int64) {
	s.db.Exec(`delete from collaborators where repo = ? and user = ?`, repo, user)
}

func (s *Store) Collaborators(repo int64) ([]User, error) {
	rows, err := s.db.Query(`select u.id, u.name, u.created from collaborators c join users u on u.id = c.user where c.repo = ? order by u.name`, repo)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []User
	for rows.Next() {
		var u User
		var created int64
		if err := rows.Scan(&u.ID, &u.Name, &created); err != nil {
			return nil, err
		}
		u.Created = time.Unix(created, 0)
		out = append(out, u)
	}
	return out, rows.Err()
}

func (s *Store) IsCollaborator(repo, user int64) bool {
	var n int
	s.db.QueryRow(`select count(*) from collaborators where repo = ? and user = ?`, repo, user).Scan(&n)
	return n > 0
}

func (s *Store) CanWrite(repo Repo, user *User) bool {
	if user == nil {
		return false
	}
	return user.ID == repo.Owner.ID || s.IsCollaborator(repo.ID, user.ID)
}

func (s *Store) CanRead(repo Repo, user *User) bool {
	if !repo.Private {
		return true
	}
	return s.CanWrite(repo, user)
}

func (s *Store) SharedRepos(user int64) ([]Repo, error) {
	rows, err := s.db.Query(`select `+repoColumns+` join collaborators c on c.repo = r.id where c.user = ? order by u.name, r.name`, user)
	if err != nil {
		return nil, err
	}
	return scanRepos(rows)
}

type PGPKey struct {
	ID          int64
	Fingerprint string
	Created     time.Time
}

func (s *Store) AddPGP(user int64, fingerprint, armored string) error {
	_, err := s.db.Exec(`insert into pgp(user, fingerprint, armored, created) values (?, ?, ?, ?)`, user, fingerprint, armored, time.Now().Unix())
	if err != nil && strings.Contains(err.Error(), "UNIQUE") {
		return errors.New("That key is already registered")
	}
	return err
}

func (s *Store) PGPKeys(user int64) ([]PGPKey, error) {
	rows, err := s.db.Query(`select id, fingerprint, created from pgp where user = ? order by id`, user)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []PGPKey
	for rows.Next() {
		var k PGPKey
		var created int64
		if err := rows.Scan(&k.ID, &k.Fingerprint, &created); err != nil {
			return nil, err
		}
		k.Created = time.Unix(created, 0)
		out = append(out, k)
	}
	return out, rows.Err()
}

func (s *Store) DeletePGP(user, id int64) {
	s.db.Exec(`delete from pgp where user = ? and id = ?`, user, id)
}

func (s *Store) AllPGP() ([]string, error) {
	rows, err := s.db.Query(`select armored from pgp order by id`)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []string
	for rows.Next() {
		var a string
		if err := rows.Scan(&a); err != nil {
			return nil, err
		}
		out = append(out, a)
	}
	return out, rows.Err()
}

func (s *Store) UserByPGP(fingerprint string) (User, bool) {
	var user int64
	if err := s.db.QueryRow(`select user from pgp where fingerprint = ?`, strings.ToUpper(fingerprint)).Scan(&user); err != nil {
		return User{}, false
	}
	u, err := s.userByID(user)
	return u, err == nil
}

func (s *Store) PublicKeys(user int64) ([]string, []string) {
	var ssh, pgp []string
	rows, err := s.db.Query(`select public from keys where user = ? order by id`, user)
	if err == nil {
		for rows.Next() {
			var k string
			rows.Scan(&k)
			ssh = append(ssh, k)
		}
		rows.Close()
	}
	rows, err = s.db.Query(`select armored from pgp where user = ? order by id`, user)
	if err == nil {
		for rows.Next() {
			var k string
			rows.Scan(&k)
			pgp = append(pgp, k)
		}
		rows.Close()
	}
	return ssh, pgp
}

type Account struct {
	Email    string
	Verified bool
	Notify   bool
	TOTP     string
	Recovery string
}

func (s *Store) Account(user int64) Account {
	var a Account
	var verified, notify int
	s.db.QueryRow(`select email, verified, notify, totp, recovery from users where id = ?`, user).Scan(&a.Email, &verified, &notify, &a.TOTP, &a.Recovery)
	a.Verified, a.Notify = verified != 0, notify != 0
	return a
}

func (s *Store) SetEmail(user int64, email string) error {
	email = strings.TrimSpace(strings.ToLower(email))
	if email != "" && (!strings.Contains(email, "@") || len(email) > 200) {
		return errors.New("That does not look like an email address")
	}
	_, err := s.db.Exec(`update users set email = ?, verified = 0 where id = ?`, email, user)
	return err
}

func (s *Store) SetNotify(user int64, on bool) {
	s.db.Exec(`update users set notify = ? where id = ?`, on, user)
}

func (s *Store) VerifiedEmail(user int64) string {
	a := s.Account(user)
	if a.Verified && a.Notify {
		return a.Email
	}
	return ""
}

func (s *Store) CreateMailToken(user int64, kind, email string) (string, error) {
	token := random(24)
	s.db.Exec(`delete from mailtokens where user = ? and kind = ?`, user, kind)
	_, err := s.db.Exec(`insert into mailtokens(token, user, kind, email, created) values (?, ?, ?, ?, ?)`, token, user, kind, email, time.Now().Unix())
	return token, err
}

func (s *Store) UseMailToken(token, kind string) (int64, string, bool) {
	var user int64
	var email string
	var created int64
	err := s.db.QueryRow(`select user, email, created from mailtokens where token = ? and kind = ?`, token, kind).Scan(&user, &email, &created)
	if err != nil || time.Since(time.Unix(created, 0)) > 24*time.Hour {
		return 0, "", false
	}
	s.db.Exec(`delete from mailtokens where token = ?`, token)
	return user, email, true
}

func (s *Store) MarkVerified(user int64, email string) {
	s.db.Exec(`update users set email = ?, verified = 1 where id = ?`, email, user)
}

func (s *Store) UserByEmail(email string) (User, error) {
	var id int64
	if err := s.db.QueryRow(`select id from users where email = ? and verified = 1 and banned = 0`, strings.ToLower(strings.TrimSpace(email))).Scan(&id); err != nil {
		return User{}, ErrNotFound
	}
	return s.userByID(id)
}

func (s *Store) SetTOTP(user int64, secret, recovery string) {
	s.db.Exec(`update users set totp = ?, recovery = ? where id = ?`, secret, recovery, user)
}

func (s *Store) SetBanned(name string, banned bool) error {
	res, err := s.db.Exec(`update users set banned = ? where name = ?`, banned, name)
	if err != nil {
		return err
	}
	if n, _ := res.RowsAffected(); n == 0 {
		return ErrNotFound
	}
	s.db.Exec(`delete from sessions where user = (select id from users where name = ?)`, name)
	return nil
}

func (s *Store) DeleteUser(name string) error {
	res, err := s.db.Exec(`delete from users where name = ?`, name)
	if err != nil {
		return err
	}
	if n, _ := res.RowsAffected(); n == 0 {
		return ErrNotFound
	}
	return nil
}

func (s *Store) RenameRepo(id int64, name string) error {
	if !validName(name) || name == "avatar" || name == "stars" || name == "feed" {
		return errors.New("Repository names are lowercase letters, digits, dot, dash or underscore")
	}
	_, err := s.db.Exec(`update repos set name = ? where id = ?`, name, id)
	if err != nil && strings.Contains(err.Error(), "UNIQUE") {
		return errors.New("A repository with that name already exists")
	}
	return err
}

func (s *Store) TransferRepo(id int64, owner int64) error {
	_, err := s.db.Exec(`update repos set owner = ? where id = ?`, owner, id)
	if err != nil && strings.Contains(err.Error(), "UNIQUE") {
		return errors.New("That user already has a repository with this name")
	}
	s.db.Exec(`delete from collaborators where repo = ? and user = ?`, id, owner)
	return err
}

func (s *Store) SetArchived(id int64, archived bool) {
	s.db.Exec(`update repos set archived = ? where id = ?`, archived, id)
}

func (s *Store) Star(user, repo int64, on bool) {
	if on {
		s.db.Exec(`insert or ignore into stars(user, repo, created) values (?, ?, ?)`, user, repo, time.Now().Unix())
	} else {
		s.db.Exec(`delete from stars where user = ? and repo = ?`, user, repo)
	}
}

func (s *Store) Starred(user, repo int64) bool {
	var n int
	s.db.QueryRow(`select count(*) from stars where user = ? and repo = ?`, user, repo).Scan(&n)
	return n > 0
}

func (s *Store) StarCount(repo int64) int {
	var n int
	s.db.QueryRow(`select count(*) from stars where repo = ?`, repo).Scan(&n)
	return n
}

func (s *Store) StarredRepos(user int64) ([]Repo, error) {
	rows, err := s.db.Query(`select `+repoColumns+` join stars st on st.repo = r.id where st.user = ? and r.private = 0 order by st.created desc`, user)
	if err != nil {
		return nil, err
	}
	return scanRepos(rows)
}

func (s *Store) CreateInvite() (string, error) {
	code := random(12)
	_, err := s.db.Exec(`insert into invites(code) values (?)`, code)
	return code, err
}

func (s *Store) UseInvite(code string) bool {
	res, err := s.db.Exec(`update invites set used = 1 where code = ? and used = 0`, code)
	if err != nil {
		return false
	}
	n, _ := res.RowsAffected()
	return n == 1
}

func (s *Store) Stats() (users, repos int) {
	s.db.QueryRow(`select count(*) from users`).Scan(&users)
	s.db.QueryRow(`select count(*) from repos where private = 0`).Scan(&repos)
	return
}

func (r Repo) Path() string {
	return fmt.Sprintf("~%s/%s", r.Owner.Name, r.Name)
}