// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by a GPL license that can be found in the LICENSE file.
module main

import time

struct Commit {
mut:
	id         int @[primary; sql: serial]
	author_id  int
	author     string
	hash       string @[unique: 'commit']
	created_at int
	repo_id    int @[unique: 'commit']
	message    string
}

struct BranchCommit {
mut:
	id        int @[primary; sql: serial]
	branch_id int @[unique: 'branch_commit']
	commit_id int @[unique: 'branch_commit']
}

fn (commit Commit) relative() string {
	return time.unix(commit.created_at).relative()
}

fn (commit Commit) short_hash() string {
	if commit.hash.len <= 7 {
		return commit.hash
	}
	return commit.hash[..7]
}

fn row_to_commit(row []string) Commit {
	if row.len < 7 {
		return Commit{}
	}
	return Commit{
		id:         row[0].int()
		author_id:  row[1].int()
		author:     row[2]
		hash:       row[3]
		created_at: row[4].int()
		repo_id:    row[5].int()
		message:    row[6]
	}
}

const commit_select_cols = 'c.id, c.author_id, c.author, c.hash, c.created_at, c.repo_id, c.message'

fn (mut app App) commit_exists(repo_id int, branch_id int, hash string) bool {
	rows := db_exec_values(mut app.db,
		'select 1 from ${sql_table('Commit')} c join ${sql_table('BranchCommit')} bc on bc.commit_id = c.id where c.repo_id = ${repo_id} and bc.branch_id = ${branch_id} and c.hash = ${sql_literal(hash)} limit 1') or {
		return false
	}
	return rows.len > 0
}

fn (mut app App) add_commit(repo_id int, branch_id int, last_hash string, author string, author_id int, message string, date int) ! {
	mut existing := app.find_repo_commit_by_hash(repo_id, last_hash)
	mut commit_id := existing.id
	if commit_id == 0 {
		new_commit := Commit{
			author_id:  author_id
			author:     author
			hash:       last_hash
			created_at: date
			repo_id:    repo_id
			message:    message
		}
		sql app.db {
			insert new_commit into Commit
		}!
		commit_id = db_last_insert_id(mut app.db)
	}
	link := BranchCommit{
		branch_id: branch_id
		commit_id: commit_id
	}
	sql app.db {
		insert link into BranchCommit
	}!
}

fn (mut app App) find_repo_commits_as_page(repo_id int, branch_id int, offset int) []Commit {
	rows := db_exec_values(mut app.db,
		'select ${commit_select_cols} from ${sql_table('Commit')} c join ${sql_table('BranchCommit')} bc on bc.commit_id = c.id where c.repo_id = ${repo_id} and bc.branch_id = ${branch_id} order by c.created_at desc limit 35 offset ${offset}') or {
		return []Commit{}
	}
	mut commits := []Commit{cap: rows.len}
	for row in rows {
		commits << row_to_commit(row)
	}
	return commits
}

fn (mut app App) get_repo_commit_count(repo_id int, branch_id int) int {
	rows := db_exec_values(mut app.db,
		'select count(*) from ${sql_table('BranchCommit')} where branch_id = ${branch_id}') or {
		return 0
	}
	if rows.len == 0 || rows[0].len == 0 {
		return 0
	}
	return rows[0][0].int()
}

fn (mut app App) find_repo_commit_by_hash(repo_id int, hash string) Commit {
	commits := sql app.db {
		select from Commit where repo_id == repo_id && hash == hash
	} or { []Commit{} }
	if commits.len == 1 {
		return commits[0]
	}
	return Commit{}
}

fn (mut app App) find_repo_last_commit(repo_id int, branch_id int) Commit {
	rows := db_exec_values(mut app.db,
		'select ${commit_select_cols} from ${sql_table('Commit')} c join ${sql_table('BranchCommit')} bc on bc.commit_id = c.id where c.repo_id = ${repo_id} and bc.branch_id = ${branch_id} order by c.created_at desc limit 1') or {
		return Commit{}
	}
	if rows.len == 0 {
		return Commit{}
	}
	return row_to_commit(rows[0])
}

fn (app App) find_repo_last_commit_time(repo_id int) int {
	commits := sql app.db {
		select from Commit where repo_id == repo_id order by created_at desc limit 1
	} or { return 0 }
	if commits.len == 0 {
		return 0
	}
	return commits[0].created_at
}

const activity_weeks = 12

fn (app App) get_repo_activity_buckets(repo_id int) []int {
	week_seconds := 7 * 24 * 3600
	now := int(time.now().unix())
	cutoff := now - activity_weeks * week_seconds
	commits := sql app.db {
		select from Commit where repo_id == repo_id && created_at >= cutoff
	} or { []Commit{} }
	mut buckets := []int{len: activity_weeks}
	for c in commits {
		idx := (c.created_at - cutoff) / week_seconds
		if idx >= 0 && idx < activity_weeks {
			buckets[idx]++
		}
	}
	return buckets
}

// get_user_daily_activity returns commit counts per day for the given user
// over the past `days` days. Index 0 is the oldest day, index `days-1` is today.
fn (app App) get_user_daily_activity(user_id int, days int) []int {
	day_seconds := 24 * 3600
	now := time.now()
	// Anchor to the start of today (local), so today is always the last bucket.
	today_start := i64(time.new(year: now.year, month: now.month, day: now.day).unix())
	cutoff := int(today_start) - (days - 1) * day_seconds
	commits := sql app.db {
		select from Commit where author_id == user_id && created_at >= cutoff
	} or { []Commit{} }
	mut buckets := []int{len: days}
	for c in commits {
		idx := (c.created_at - cutoff) / day_seconds
		if idx >= 0 && idx < days {
			buckets[idx]++
		}
	}
	return buckets
}