module main

import time
import math
import os
import veb

pub fn (mut app App) running_since() string {
	duration := time.now().unix() - app.started_at

	seconds_in_hour := 60 * 60

	days := int(math.floor(f64(duration) / f64(seconds_in_hour * 24)))
	hours := int(math.fmod(math.floor(f64(duration) / f64(seconds_in_hour)), 24))
	minutes := int(math.floor(f64(duration) / 60.0)) % 60
	seconds := duration % 60

	return '${days} days ${hours} hours ${minutes} minutes and ${seconds} seconds'
}

pub fn (mut ctx Context) make_path(branch_name string, i int) string {
	if i == 0 {
		return ctx.path_split[..i + 1].join('/')
	}
	mut s := ctx.path_split[0]
	s += '/tree/${branch_name}/'
	s += ctx.path_split[1..i + 1].join('/')
	return s
}

fn create_directory_if_not_exists(path string) {
	if !os.exists(path) {
		os.mkdir(path) or { panic('cannot create ${path} directory') }
	}
}

fn calculate_pages(count int, per_page int) int {
	if count == 0 {
		return 0
	}

	return int(math.ceil(f32(count) / f32(per_page))) - 1
}

fn generate_prev_next_pages(page int) (int, int) {
	prev_page := if page > 0 { page - 1 } else { 0 }
	next_page := page + 1

	return prev_page, next_page
}

fn check_first_page(page int) bool {
	return page == 0
}

fn check_last_page(total int, offset int, per_page int) bool {
	return (total - offset) < per_page
}

const is_dev = true

fn css2(s string) veb.RawHtml {
	if is_dev {
		return '<link href="http://localhost:8000/${s}" rel="stylesheet" type="text/css">'
	} else {
		return '<link href="/static/${s}" rel="stylesheet" type="text/css">'
	}
}

fn minify_pr_files_html(mut ctx Context) bool {
	if ctx.res.body.len == 0 {
		return true
	}
	minified := strip_intertag_whitespace(ctx.res.body)
	if minified.len != ctx.res.body.len {
		ctx.res.body = minified
		ctx.res.header.set(.content_length, ctx.res.body.len.str())
	}
	return true
}

fn strip_intertag_whitespace(s string) string {
	mut out := []u8{cap: s.len}
	mut i := 0
	mut preserve_whitespace_depth := 0
	for i < s.len {
		ch := s[i]
		if ch == `<` {
			tag_end := html_tag_end(s, i)
			if tag_end == -1 {
				out << ch
				i++
				continue
			}
			tag_name, closing, self_closing := html_tag_info(s, i, tag_end)
			compact_tag := compact_html_tag(s, i, tag_end)
			for k := 0; k < compact_tag.len; k++ {
				out << compact_tag[k]
			}
			if preserves_html_whitespace(tag_name) {
				if closing {
					if preserve_whitespace_depth > 0 {
						preserve_whitespace_depth--
					}
				} else if !self_closing {
					preserve_whitespace_depth++
				}
			}
			i = tag_end + 1
			continue
		}
		if is_html_space(ch) {
			mut j := i + 1
			mut has_indentation := ch != ` `
			for j < s.len && is_html_space(s[j]) {
				if s[j] != ` ` {
					has_indentation = true
				}
				j++
			}
			prev_is_tag_end := out.len > 0 && out[out.len - 1] == `>`
			next_is_tag_start := j < s.len && s[j] == `<`
			should_strip := preserve_whitespace_depth == 0
				&& ((prev_is_tag_end && next_is_tag_start)
				|| (has_indentation && (prev_is_tag_end || next_is_tag_start)))
			if should_strip {
				i = j
				continue
			}
			if preserve_whitespace_depth == 0 && has_indentation {
				out << ` `
			} else {
				for k := i; k < j; k++ {
					out << s[k]
				}
			}
			i = j
			continue
		}
		out << ch
		i++
	}
	return out.bytestr()
}

fn compact_html_tag(s string, start int, end int) string {
	mut out := []u8{cap: end - start + 1}
	mut i := start
	for i <= end {
		ch := s[i]
		if ch == `"` || ch == `'` {
			quote := ch
			out << ch
			mut value_end := i + 1
			for value_end <= end && s[value_end] != quote {
				value_end++
			}
			if value_end <= end {
				mut value_start := i + 1
				mut value_finish := value_end
				for value_start < value_finish && is_html_space(s[value_start]) {
					value_start++
				}
				for value_finish > value_start && is_html_space(s[value_finish - 1]) {
					value_finish--
				}
				for k := value_start; k < value_finish; k++ {
					out << s[k]
				}
				out << quote
				i = value_end + 1
				continue
			}
		}
		out << ch
		i++
	}
	return out.bytestr()
}

fn html_tag_end(s string, start int) int {
	mut quote := u8(0)
	for i := start + 1; i < s.len; i++ {
		ch := s[i]
		if quote != 0 {
			if ch == quote {
				quote = 0
			}
		} else if ch == `"` || ch == `'` {
			quote = ch
		} else if ch == `>` {
			return i
		}
	}
	return -1
}

fn html_tag_info(s string, start int, end int) (string, bool, bool) {
	mut i := start + 1
	mut closing := false
	if i < end && s[i] == `/` {
		closing = true
		i++
	}
	for i < end && is_html_space(s[i]) {
		i++
	}
	name_start := i
	for i < end && is_html_tag_name_char(s[i]) {
		i++
	}
	name := s[name_start..i].to_lower()
	mut j := end - 1
	for j > start && is_html_space(s[j]) {
		j--
	}
	self_closing := !closing && j > start && s[j] == `/`
	return name, closing, self_closing
}

fn preserves_html_whitespace(tag_name string) bool {
	return tag_name in ['s', 'pre', 'textarea', 'script', 'style']
}

fn is_html_tag_name_char(ch u8) bool {
	return (ch >= `a` && ch <= `z`) || (ch >= `A` && ch <= `Z`)
		|| (ch >= `0` && ch <= `9`) || ch == `-` || ch == `_` || ch == `:`
}

fn is_html_space(ch u8) bool {
	return ch == ` ` || ch == `\n` || ch == `\t` || ch == `\r`
}