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`,
}

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
	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
		}
	}
	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 = ?`, 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 user from sessions where id = ? and created > ?`, 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 user from keys where fingerprint = ?`, 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 = ?`, 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" {
		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 int
		var tags string
		var created, ucreated int64
		if err := rows.Scan(&r.ID, &r.Name, &r.Description, &private, &tags, &r.Parent, &created, &r.Owner.ID, &r.Owner.Name, &ucreated); err != nil {
			return nil, err
		}
		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.created, u.id, u.name, u.created from repos r join users u on u.id = r.owner`

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) RecentRepos(n int) ([]Repo, error) {
	rows, err := s.db.Query(`select `+repoColumns+` where r.private = 0 order by r.created desc limit ?`, n)
	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) 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)
}