package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"os"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"
	"unicode/utf8"
)

const (
	Host          = "0.0.0.0"
	Port          = "2323"
	WikiJSBaseURL = "https://wiki.teletype.hu"
	GamesAPIURL   = "https://games.teletype.hu/api/software"
	W             = 70
)

// ANSI Colors
const (
	R   = "\033[0m"
	B   = "\033[1m"
	DIM = "\033[2m"
	CY  = "\033[1;36m"
	YL  = "\033[1;33m"
	GR  = "\033[1;32m"
	RD  = "\033[1;31m"
	MG  = "\033[1;35m"
	WH  = "\033[1;37m"
	BL  = "\033[1;34m"
	GY  = "\033[0;37m"
)

type Message struct {
	User      string
	Timestamp string
	Text      string
}

var (
	messages    []Message
	onlineUsers = make(map[string]string) // addr -> username
	mu          sync.Mutex
	wikiToken   = os.Getenv("WEBAPP_WIKIJS_TOKEN")
)

const Banner = `
  ████████╗███████╗██╗     ███████╗████████╗██╗   ██╗██████╗ ███████╗
     ██╔══╝██╔════╝██║     ██╔════╝╚══██╔══╝╚██╗ ██╔╝██╔══██╗██╔════╝
     ██║   █████╗  ██║     █████╗     ██║    ╚████╔╝ ██████╔╝█████╗  
     ██║   ██╔══╝  ██║     ██╔══╝     ██║     ╚██╔╝  ██╔═══╝ ██╔══╝  
     ██║   ███████╗███████╗███████╗   ██║      ██║   ██║     ███████╗
     ╚═╝   ╚══════╝╚══════╝╚══════╝   ╚═╝      ╚═╝   ╚═╝     ╚══════╝

                  ░░  BBS  v2.0  ░░  teletype.hu  ░░
          Üdvözölünk a Teletype közösségi hirdetőtábláján!
`

func main() {
	ln, err := net.Listen("tcp", Host+":"+Port)
	if err != nil {
		fmt.Printf("Hiba a szerver indításakor: %v\n", err)
		os.Exit(1)
	}
	defer ln.Close()

	fmt.Printf("Teletype BBS fut → telnet localhost %s\n", Port)
	fmt.Printf("Wiki: %s\n", WikiJSBaseURL)
	fmt.Printf("Games API: %s\n", GamesAPIURL)
	tokenStatus := "✗ nincs beállítva"
	if wikiToken != "" {
		tokenStatus = "✓ beállítva"
	}
	fmt.Printf("Token: %s\n", tokenStatus)
	fmt.Println("Leállítás: Ctrl+C")

	for {
		conn, err := ln.Accept()
		if err != nil {
			fmt.Printf("Hiba a kapcsolódáskor: %v\n", err)
			continue
		}
		fmt.Printf("[+] Kapcsolódott: %s\n", conn.RemoteAddr().String())
		go handleClient(conn)
	}
}

func handleClient(conn net.Conn) {
	defer conn.Close()
	addr := conn.RemoteAddr().String()

	// Telnet negotiation:
	// IAC WILL ECHO (255, 251, 1)
	// IAC WILL SUPPRESS GO AHEAD (255, 251, 3)
	// IAC DONT LINEMODE (255, 254, 34)
	send(conn, "\xff\xfb\x01\xff\xfb\x03\xff\xfe\x22")

	send(conn, CY+Banner+R)
	send(conn, fmt.Sprintf("\n%sAdd meg a nevedet:%s ", WH, R))

	username, err := readLine(conn)
	if err != nil {
		return
	}
	username = strings.TrimSpace(username)
	if username == "" {
		username = "Névtelen"
	}
	if len(username) > 20 {
		username = username[:20]
	}

	mu.Lock()
	onlineUsers[addr] = username
	mu.Unlock()

	defer func() {
		mu.Lock()
		delete(onlineUsers, addr)
		mu.Unlock()
	}()

	send(conn, fmt.Sprintf("\r\n%sSzia, %s%s%s! Üdv a Teletype BBS-en!%s\r\n", GR, WH, username, GR, R))

	for {
		send(conn, mainMenu(username))
		choice, err := readLine(conn)
		if err != nil {
			break
		}
		c := strings.ToUpper(strings.TrimSpace(choice))

		switch c {
		case "1":
			showUzenopal(conn, username)
		case "2":
			showWikiList(conn, "blog", BL, "📰  BLOG BEJEGYZÉSEK")
		case "3":
			showWikiList(conn, "howto", MG, "📖  HOWTO ÚTMUTATÓK")
		case "4":
			showGames(conn)
		case "5":
			showOnline(conn, addr)
		case "6":
			showSysinfo(conn)
		case "Q":
			send(conn, fmt.Sprintf("\r\n%sViszlát, %s! 👋%s\r\n\r\n", RD, username, R))
			return
		}
	}
}

func visibleLen(s string) int {
	re := regexp.MustCompile(`\033\[[0-9;]*m`)
	return utf8.RuneCountInString(re.ReplaceAllString(s, ""))
}

func padLine(content string, width int) string {
	vLen := visibleLen(content)
	padding := width - vLen
	if padding < 0 {
		padding = 0
	}
	return content + strings.Repeat(" ", padding)
}

func mainMenu(username string) string {
	headerLine := strings.Repeat("═", W)

	// Sorok összeállítása pontos hosszal
	l1 := padLine(fmt.Sprintf("  %sFŐMENÜ%s  %s@%s%s", YL, R, GY, username, R), W)
	l2 := padLine(fmt.Sprintf("  %s[1]%s Üzenőfal", GR, R), W/2) + padLine(fmt.Sprintf("  %s[2]%s Blog bejegyzések", BL, R), W/2)
	l3 := padLine(fmt.Sprintf("  %s[3]%s HowTo útmutatók", MG, R), W/2) + padLine(fmt.Sprintf("  %s[4]%s Játékkatalógus", YL, R), W/2)
	l4 := padLine(fmt.Sprintf("  %s[5]%s Online felhasználók", CY, R), W/2) + padLine(fmt.Sprintf("  %s[6]%s Rendszerinfo", GY, R), W/2)
	l5 := padLine(fmt.Sprintf("  %s[Q]%s Kilépés", RD, R), W)

	return fmt.Sprintf(
		"\n%s╔%s╗%s\n"+
			"%s║%s%s║%s\n"+
			"%s╠%s╣%s\n"+
			"%s║%s%s║%s\n"+
			"%s║%s%s║%s\n"+
			"%s║%s%s║%s\n"+
			"%s║%s%s║%s\n"+
			"%s╚%s╝%s\nVálasztás: ",
		WH, headerLine, R,
		WH, l1, WH, R,
		WH, headerLine, R,
		WH, l2, WH, R,
		WH, l3, WH, R,
		WH, l4, WH, R,
		WH, l5, WH, R,
		WH, headerLine, R,
	)
}

// ── Telnet I/O ───────────────────────────────────────────────────────────────

func send(conn net.Conn, text string) {
	// Minden \n-t \r\n-re cserélünk, ha még nem az, hogy Telnet-en ne essen szét az ASCII art
	normalized := strings.ReplaceAll(text, "\r\n", "\n")
	normalized = strings.ReplaceAll(normalized, "\n", "\r\n")
	conn.Write([]byte(normalized))
}

func readLine(conn net.Conn) (string, error) {
	var buf bytes.Buffer
	for {
		b := make([]byte, 1)
		_, err := conn.Read(b)
		if err != nil {
			return "", err
		}
		ch := b[0]

		// Telnet IAC (Interpret As Command)
		if ch == 255 {
			cmd := make([]byte, 2)
			_, err := conn.Read(cmd)
			if err != nil {
				return "", err
			}
			if cmd[0] == 250 { // SB
				for {
					tmp := make([]byte, 1)
					_, err := conn.Read(tmp)
					if err != nil || tmp[0] == 240 { // SE
						break
					}
				}
			}
			continue
		}

		// Enter billentyű (Telnetnél \r\n vagy csak \r)
		if ch == '\r' || ch == '\n' {
			res := buf.String()
			send(conn, "\r\n") // Visszhangozzuk a sortörést
			return res, nil
		}

		// Backspace (8=BS, 127=DEL)
		if ch == 8 || ch == 127 {
			if buf.Len() > 0 {
				curr := buf.Bytes()
				buf.Reset()
				buf.Write(curr[:len(curr)-1])
				send(conn, "\b \b")
			}
			continue
		}

		// Csak a látható karaktereket gyűjtjük
		if ch >= 32 && ch < 127 {
			buf.WriteByte(ch)
			send(conn, string(ch))
		}
	}
}

func pause(conn net.Conn) {
	send(conn, fmt.Sprintf("\r\n%s  [ Nyomj ENTER-t... ]%s ", GY, R))
	readLine(conn)
}

// ── API hívások ───────────────────────────────────────────────────────────────

func graphql(query string) (map[string]interface{}, error) {
	payload := map[string]string{"query": query}
	data, _ := json.Marshal(payload)

	req, err := http.NewRequest("POST", WikiJSBaseURL+"/graphql", bytes.NewBuffer(data))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")
	if wikiToken != "" {
		req.Header.Set("Authorization", "Bearer "+wikiToken)
	}

	client := &http.Client{Timeout: 12 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var result map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}
	return result, nil
}

type WikiPage struct {
	ID          interface{} `json:"id"`
	Path        string      `json:"path"`
	Title       string      `json:"title"`
	Description string      `json:"description"`
	CreatedAt   string      `json:"createdAt"`
	UpdatedAt   string      `json:"updatedAt"`
	Locale      string      `json:"locale"`
}

func fetchWikiList(tag string) ([]WikiPage, error) {
	q := fmt.Sprintf(`{ pages { list(orderBy: CREATED, orderByDirection: DESC, tags: ["%s"]) { id path title description createdAt updatedAt locale } } }`, tag)
	res, err := graphql(q)
	if err != nil {
		return nil, err
	}

	data, ok := res["data"].(map[string]interface{})
	if !ok {
		return nil, fmt.Errorf("invalid response format")
	}
	pages, ok := data["pages"].(map[string]interface{})
	if !ok {
		return nil, fmt.Errorf("invalid response format")
	}
	listRaw, ok := pages["list"].([]interface{})
	if !ok {
		return nil, fmt.Errorf("invalid response format")
	}

	var list []WikiPage
	jsonBytes, _ := json.Marshal(listRaw)
	json.Unmarshal(jsonBytes, &list)
	return list, nil
}

func fetchWikiContent(pageID interface{}) (string, error) {
	var idStr string
	switch v := pageID.(type) {
	case string:
		idStr = v
	case float64:
		idStr = fmt.Sprintf("%.0f", v)
	default:
		idStr = fmt.Sprintf("%v", v)
	}

	q := fmt.Sprintf(`{ pages { single(id: %s) { content } } }`, idStr)
	res, err := graphql(q)
	if err != nil {
		return "", err
	}

	data := res["data"].(map[string]interface{})
	pages := data["pages"].(map[string]interface{})
	single := pages["single"].(map[string]interface{})
	return single["content"].(string), nil
}

type SoftwareEntry struct {
	Software struct {
		Title    string `json:"title"`
		Platform string `json:"platform"`
		Author   string `json:"author"`
		Desc     string `json:"desc"`
	} `json:"software"`
	Releases      []interface{} `json:"releases"`
	LatestRelease *struct {
		Version         string `json:"version"`
		HTMLFolderPath  string `json:"htmlFolderPath"`
		CartridgePath   string `json:"cartridgePath"`
		SourcePath      string `json:"sourcePath"`
		DocsFolderPath  string `json:"docsFolderPath"`
	} `json:"latestRelease"`
}

func fetchGames() ([]SoftwareEntry, error) {
	client := &http.Client{Timeout: 12 * time.Second}
	resp, err := client.Get(GamesAPIURL)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var result struct {
		Softwares []SoftwareEntry `json:"softwares"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}
	return result.Softwares, nil
}

// ── Szöveg segédek ────────────────────────────────────────────────────────────

func boxHeader(title string, color string) string {
	line := strings.Repeat("═", W)
	titleLen := utf8.RuneCountInString(title)
	padding := (W - 2 - titleLen) / 2
	if padding < 0 {
		padding = 0
	}
	inner := strings.Repeat(" ", padding) + title + strings.Repeat(" ", W-2-titleLen-padding)
	return fmt.Sprintf(
		"\n%s%s%s\n%s║%s %s%s%s %s║%s\n%s%s%s\n",
		color, line, R,
		color, R, B, inner, R, color, R,
		color, line, R,
	)
}

func hr(char string, color string) string {
	return fmt.Sprintf("%s%s%s", color, strings.Repeat(char, W), R)
}

func fmtDate(s string) string {
	t, err := time.Parse(time.RFC3339, strings.Replace(s, "Z", "+00:00", 1))
	if err != nil {
		if len(s) >= 10 {
			return s[:10]
		}
		return "–"
	}
	return t.Format("2006-01-02")
}

func stripMD(text string) string {
	reImg := regexp.MustCompile(`!\[.*?\]\(.*?\)|\[(.*?)\]\(.*?\)|#{1,6}\s*|[*_` + "`" + `~>|]`)
	text = reImg.ReplaceAllStringFunc(text, func(s string) string {
		if strings.HasPrefix(s, "[") {
			sub := regexp.MustCompile(`\[(.*?)\]\(.*?\)` )
			matches := sub.FindStringSubmatch(s)
			if len(matches) > 1 {
				return matches[1]
			}
		}
		if strings.HasPrefix(s, "!") || strings.HasPrefix(s, "#") || strings.ContainsAny(s, "*_`~>|") {
			return ""
		}
		return s
	})
	return strings.TrimSpace(text)
}

func wrapped(text string, indent int, maxChars int) string {
	if len(text) > maxChars {
		text = text[:maxChars]
	}
	text = stripMD(text)
	prefix := strings.Repeat(" ", indent)
	var lines []string

	paras := strings.Split(text, "\n")
	for _, para := range paras {
		para = strings.TrimSpace(para)
		if para == "" {
			lines = append(lines, "")
			continue
		}
		
		words := strings.Fields(para)
		if len(words) == 0 {
			continue
		}
		
		currentLine := prefix + words[0]
		for _, word := range words[1:] {
			if len(currentLine)+1+len(word) > W {
				lines = append(lines, currentLine)
				currentLine = prefix + word
			} else {
				currentLine += " " + word
			}
		}
		lines = append(lines, currentLine)
	}
	return strings.Join(lines, "\r\n")
}

// ── Menük ─────────────────────────────────────────────────────────────────────

func showUzenopal(conn net.Conn, username string) {
	send(conn, boxHeader("📋  ÜZENŐFAL", GR))
	mu.Lock()
	snap := make([]Message, len(messages))
	copy(snap, messages)
	mu.Unlock()

	if len(snap) == 0 {
		send(conn, fmt.Sprintf("  %s(Még nincs üzenet — legyél az első!)%s\r\n", GY, R))
	} else {
		start := 0
		if len(snap) > 30 {
			start = len(snap) - 30
		}
		for i, msg := range snap[start:] {
			send(conn, fmt.Sprintf("  %s%02d%s %s%s%s  %s%s:%s %s\r\n", GR, i+1, R, GY, msg.Timestamp, R, WH, msg.User, R, msg.Text))
		}
	}

	send(conn, fmt.Sprintf("\r\n%s[N]%s Új üzenet írása  %s[ENTER]%s Vissza → ", GY, R, GY, R))
	choice, _ := readLine(conn)
	if strings.ToUpper(strings.TrimSpace(choice)) == "N" {
		send(conn, fmt.Sprintf("\r\n%sÜzenet szövege:%s ", WH, R))
		msgText, _ := readLine(conn)
		msgText = strings.TrimSpace(msgText)
		if msgText != "" {
			if len(msgText) > 200 {
				msgText = msgText[:200]
			}
			ts := time.Now().Format("01-02 15:04")
			mu.Lock()
			messages = append(messages, Message{User: username, Timestamp: ts, Text: msgText})
			mu.Unlock()
			send(conn, fmt.Sprintf("\r\n%s✓ Elküldve!%s\r\n", GR, R))
		} else {
			send(conn, fmt.Sprintf("\r\n%s(Üres – nem küldtük el)%s\r\n", GY, R))
		}
	}
}

func showWikiList(conn net.Conn, tag string, color string, title string) {
	send(conn, boxHeader(title, color))
	send(conn, fmt.Sprintf("  %sTöltés folyamatban...%s\r\n", GY, R))
	
	pages, err := fetchWikiList(tag)
	if err != nil {
		send(conn, fmt.Sprintf("\r\n%sKapcsolati hiba: %v%s\r\n", RD, err, R))
		pause(conn)
		return
	}

	// clear "Töltés" line
	send(conn, "\r\033[A\033[2K")

	if len(pages) == 0 {
		send(conn, fmt.Sprintf("  %sNincs találat a '%s' tag-re.%s\r\n", GY, tag, R))
		pause(conn)
		return
	}

	maxIdx := 25
	if len(pages) < maxIdx {
		maxIdx = len(pages)
	}

	for i, p := range pages[:maxIdx] {
		date := fmtDate(p.CreatedAt)
		if date == "–" {
			date = fmtDate(p.UpdatedAt)
		}
		titleP := p.Title
		if titleP == "" {
			titleP = p.Path
		}
		if len(titleP) > 55 {
			titleP = titleP[:55]
		}
		desc := p.Description
		if len(desc) > 60 {
			desc = desc[:60]
		}
		send(conn, fmt.Sprintf("  %s%2d%s  %s%s%s\r\n", color, i+1, R, WH, titleP, R))
		if desc != "" {
			send(conn, fmt.Sprintf("      %s%s  %s%s%s\r\n", GY, date, DIM, desc, R))
		} else {
			send(conn, fmt.Sprintf("      %s%s%s\r\n", GY, date, R))
		}
	}

	send(conn, fmt.Sprintf("\r\n%sSzám a tartalom megnyitásához, ENTER a visszalépéshez:%s ", GY, R))
	choice, _ := readLine(conn)
	choice = strings.TrimSpace(choice)
	idx, err := strconv.Atoi(choice)
	if err != nil || idx < 1 || idx > len(pages) {
		return
	}

	page := pages[idx-1]
	send(conn, fmt.Sprintf("\r\n%sTartalom betöltése...%s", GY, R))
	content, err := fetchWikiContent(page.ID)
	if err != nil {
		send(conn, fmt.Sprintf("\r\n%sHiba: %v%s\r\n", RD, err, R))
		pause(conn)
		return
	}

	send(conn, "\r\033[A\033[2K")
	send(conn, fmt.Sprintf("\r\n%s\r\n", hr("═", color)))
	send(conn, fmt.Sprintf("  %s%s%s%s\r\n", WH, B, page.Title, R))
	url := fmt.Sprintf("%s/%s/%s", WikiJSBaseURL, page.Locale, page.Path)
	send(conn, fmt.Sprintf("  %s%s   %s%s%s\r\n", GY, fmtDate(page.CreatedAt), DIM, url, R))
	send(conn, fmt.Sprintf("%s\r\n\r\n", hr("─", GY)))

	body := wrapped(content, 2, 5000)
	for _, line := range strings.Split(body, "\r\n") {
		send(conn, line+"\r\n")
	}

	send(conn, fmt.Sprintf("\r\n%s\r\n", hr("─", GY)))
	pause(conn)
}

func showGames(conn net.Conn) {
	send(conn, boxHeader("🎮  JÁTÉKKATALÓGUS", YL))
	send(conn, fmt.Sprintf("  %sTöltés folyamatban...%s\r\n", GY, R))
	
	softwares, err := fetchGames()
	if err != nil {
		send(conn, fmt.Sprintf("\r\n%sKapcsolati hiba: %v%s\r\n", RD, err, R))
		pause(conn)
		return
	}

	send(conn, "\r\033[A\033[2K")

	if len(softwares) == 0 {
		send(conn, fmt.Sprintf("  %sNincs elérhető játék.%s\r\n", GY, R))
		pause(conn)
		return
	}

	base := "https://games.teletype.hu"

	for i, entry := range softwares {
		sw := entry.Software
		lr := entry.LatestRelease

		send(conn, fmt.Sprintf("\r\n  %s%s%s\r\n", YL, strings.Repeat("─", W-4), R))
		send(conn, fmt.Sprintf("  %s%2d.%s  %s%s%s%s  %s[%s]  by %s%s\r\n", YL, i+1, R, WH, B, sw.Title, R, GY, sw.Platform, sw.Author, R))

		if sw.Desc != "" {
			wrappedDesc := wrapped(sw.Desc, 7, 1000)
			for _, line := range strings.Split(wrappedDesc, "\r\n") {
				send(conn, fmt.Sprintf("%s%s\r\n", GY, line))
			}
		}

		if lr != nil {
			badges := []string{}
			if lr.HTMLFolderPath != "" {
				badges = append(badges, fmt.Sprintf("%s[▶ Play]%s", GR, R))
			}
			if lr.CartridgePath != "" {
				badges = append(badges, fmt.Sprintf("%s[⬇ Download]%s", BL, R))
			}
			if lr.SourcePath != "" {
				badges = append(badges, fmt.Sprintf("%s[Source]%s", MG, R))
			}
			if lr.DocsFolderPath != "" {
				badges = append(badges, fmt.Sprintf("%s[Docs]%s", YL, R))
			}

			badgeStr := "–"
			if len(badges) > 0 {
				badgeStr = strings.Join(badges, "  ")
			}
			send(conn, fmt.Sprintf("       %sLegújabb: v%s%s  %s\r\n", GY, lr.Version, R, badgeStr))

			if lr.HTMLFolderPath != "" {
				url := base + lr.HTMLFolderPath
				send(conn, fmt.Sprintf("       %s▶ %s%s\r\n", DIM, url, R))
			}
		}
		send(conn, fmt.Sprintf("       %s%d verzió elérhető%s\r\n", GY, len(entry.Releases), R))
	}

	send(conn, fmt.Sprintf("\r\n%s\r\n", hr("─", YL)))
	send(conn, fmt.Sprintf("  %sTeljes katalógus: %s%s\r\n", GY, base, R))
	pause(conn)
}

func showOnline(conn net.Conn, myAddr string) {
	send(conn, boxHeader("👥  ONLINE FELHASZNÁLÓK", CY))
	mu.Lock()
	snap := make(map[string]string)
	for k, v := range onlineUsers {
		snap[k] = v
	}
	mu.Unlock()

	keys := make([]string, 0, len(snap))
	for k := range snap {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	for _, addr := range keys {
		user := snap[addr]
		marker := ""
		if addr == myAddr {
			marker = fmt.Sprintf("  %s← te%s", GR, R)
		}
		send(conn, fmt.Sprintf("  %s•%s  %s%s%s%s\r\n", CY, R, WH, user, R, marker))
	}
	send(conn, fmt.Sprintf("\r\n  %sÖsszesen: %s%d%s fő online%s\r\n", GY, WH, len(snap), GY, R))
	pause(conn)
}

func showSysinfo(conn net.Conn) {
	send(conn, boxHeader("ℹ  RENDSZERINFO", GY))
	mu.Lock()
	uc := len(onlineUsers)
	mc := len(messages)
	mu.Unlock()

	now := time.Now().Format("2006-01-02 15:04:05")
	rows := [][]string{
		{"Szerver ideje", now},
		{"Online userek", strconv.Itoa(uc)},
		{"Üzenetek száma", strconv.Itoa(mc)},
		{"Wiki URL", WikiJSBaseURL},
		{"Games API", GamesAPIURL},
		{"Token beállítva", func() string {
			if wikiToken != "" {
				return "igen"
			}
			return "nem"
		}()},
		{"Platform", "Go BBS v2.0"},
	}

	for _, row := range rows {
		send(conn, fmt.Sprintf("  %s%-18s%s  %s%s%s\r\n", GY, row[0], R, WH, row[1], R))
	}
	pause(conn)
}