package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"regexp"
	"strconv"
	"strings"
	"time"

	"gogs.bullercodeworks.com/brian/boltease"
)

const programName = "aocbot"

var db *boltease.DB
var boardID string

var slackChannel string

func main() {
	if len(os.Args) != 3 {
		fmt.Fprintf(os.Stderr, "usage: "+programName+" <slack-bot-token> <aoc-leaderboard-number>\n")
		os.Exit(1)
	}

	var err error
	var slack *Slack

	if db, err = getDatabase(); err != nil {
		panic(err)
	}
	slackChannel = "C0G3X1M5K"

	// DevICT Leaderboard: 3549
	boardID = os.Args[2]

	if slack, err = CreateSlack(os.Args[1]); err != nil {
		panic(err)
	}

	aocBotMain(slack)
}

// This is the main function for the statbot
func aocBotMain(slack *Slack) {
	// start a websocket-based Real Time API session
	fmt.Println("aoc-bot ready, ^C exits")

	writeToLog("== " + time.Now().Format(time.RFC3339) + " - Bot Started ==\n")
	var lastAoCUpdate time.Time
	go func() {
		for {
			var err error
			lastAoCUpdate = time.Now()
			var leaderboard *Leaderboard
			fmt.Println(lastAoCUpdate.Format(time.RFC3339) + ": Fetching Online Leaderboard")
			if leaderboard, err = getAoCLeaderboard(boardID); err != nil {
				fmt.Println(err.Error())
			}

			for _, v := range leaderboard.Members {
				var mbr *Member
				if mbr, err = getAoCUser(v.ID); err != nil {
					// Member doesn't exist in db, add it
					// Notify br0xen ( U030RD9NU )
					m := new(Message)
					m.Type = "message"
					m.Channel = "D0D793N5R"
					m.Text = "AoC Leaderboard has a new member! " + v.Name
					fmt.Println("New Leaderboard Member Found: " + v.Name)
					if err = slack.postMessage(*m); err != nil {
						fmt.Println(err.Error())
					}
					saveAoCUser(&v)
					continue
				}
				if mbr.Stars != v.Stars {
					// Number of stars has changed
					fmt.Println(v.ID + "(" + v.Name + "): " + v.LastStarTs.Format(time.RFC3339))
					m := new(Message)
					m.Type = "message"
					m.Channel = slackChannel
					m.Text = ":christmas_tree: " + v.Name + " now has " + strconv.Itoa(v.Stars) + " stars! :christmas_tree:"
					if err = slack.postMessage(*m); err != nil {
						fmt.Println(err.Error())
					}
					saveAoCUser(&v)
				}
			}
			time.Sleep(time.Minute * 10)
		}
	}()

	for {
		// read each incoming message
		m, err := slack.getMessage()
		if err == nil {
			writeToLog("   " + time.Now().Format(time.RFC3339) + " - Received Message\n")
			processMessage(slack, &m)
		}

	}
	writeToLog("== " + time.Now().Format(time.RFC3339) + " - Bot Stopped ==\n\n")
}

func processMessage(slack *Slack, m *Message) {
	if mb, me := json.Marshal(m); me == nil {
		// Write the JSON representation to the log
		writeToLog(string(mb) + "\n")
	}

	if m.Type == "message" || m.Type == "reaction_added" {
		var err error
		var usr *User

		// Check if we know who the user is
		usr, err = getUser(m.User)
		// If the user information hasn't been updated in the last day, update it.
		if err != nil || usr.LastUpdated.IsZero() || time.Since(usr.LastUpdated) > (time.Hour*24) {
			if u, ue := slack.getUserInfo(m.User); ue == nil {
				saveUser(u)
			}
		}

		// TODO: Process the message
		if m.Channel != "" {
			// Check if we know what the channel is
			chnl, err := getChannelInfo(m.Channel)
			var isDirectMessage bool

			// If the channel information hasn't been updated in the last day, update it.
			if err != nil || chnl.LastUpdated.IsZero() || time.Since(chnl.LastUpdated) > (time.Hour*24) {
				// Either we don't have this channel, or it's a direct message
				if c, ce := slack.getChannelInfo(m.Channel); ce == nil {
					// Save channel info
					saveChannelInfo(c)
				} else {
					isDirectMessage = true
				}
			}
			if isDirectMessage {
				if m.User == "U030RD9NU" {
					// message from br0xen
					if strings.HasPrefix(m.Text, "!aoc") {
						var slackId, aocNm, op string
						flds := strings.Fields(m.Text)
						if len(flds) < 2 {
							// No operation specified
							return
						}
						op = flds[1]
						if op == "help" {
							// TODO: Send help message
						}
						if op == "match" {
							re := regexp.MustCompile("[<\"]([^>]*)[>\"]")
							matchUp := re.FindAllString(m.Text, -1)

							for i := range matchUp {
								if matchUp[i][0] == '<' {
									slackId = matchUp[i][1 : len(matchUp[i])-1]
								}
								if matchUp[i][0] == '"' {
									aocNm = matchUp[i][1 : len(matchUp[i])-1]
								}
							}

							var m *Member
							if m, err = getAoCUserByName(aocNm); err != nil {
								// AoC Member doesn't exist in DB
								fmt.Println("AoC User " + aocNm + " doesn't exist in DB")
								fmt.Println(err.Error())
								return
							}
							m.SlackID = slackId
							saveAoCUser(m)
						} else if op == "ping" {
							m := new(Message)
							m.Type = "message"
							m.Channel = "D0D793N5R"
							m.Text = ":christmas_tree: PONG :christmas_tree:"
							if err = slack.postMessage(*m); err != nil {
								fmt.Println(err.Error())
							}
						}
					}
					/*
					   ID:				0
					   Type:			message
					   Channel:	D0D793N5R
					   User:			U030RD9NU
					   Name:
					   Text:			testing
					   Ts:				1481044675.000003
					*/
				}
			} else {
				fmt.Println("--- Channel Message Received")
				fmt.Println(m.Channel, m.User, m.Text)
				if m.Channel == slackChannel {
					// In the AoC channel
					if strings.HasPrefix(m.Text, "!aoc") {
						var op string
						flds := strings.Fields(m.Text)
						if len(flds) < 2 {
							// No operation specified
							return
						}
						op = flds[1]
						if op == "ping" {
							m := new(Message)
							m.Type = "message"
							m.Channel = slackChannel
							m.Text = ":christmas_tree: PONG :christmas_tree:"
							if err = slack.postMessage(*m); err != nil {
								fmt.Println(err.Error())
							}
						}
					}
				}
				// TODO: Process Channel Message
				/*
					for _, proc := range messageProcessors {
						proc.ProcessChannelMessage(slack, m)
					}
				*/
			}
		}
	}
}

func getAoCLeaderboard(boardId string) (*Leaderboard, error) {
	var err error
	var req *http.Request
	var content []byte
	var resp *http.Response
	var body []byte
	leaderboard := new(Leaderboard)

	client := &http.Client{}
	boardString := "http://adventofcode.com/2016/leaderboard/private/view/" + boardId + ".json"

	req, err = http.NewRequest("GET", boardString, nil)
	// Read in cookies
	content, err = ioutil.ReadFile("./cookies")
	if err != nil {
		fmt.Println("Error reading Cookies")
		return leaderboard, err
	}
	line := strings.TrimSpace(string(content))
	req.Header.Add("Cookie", line)

	resp, err = client.Do(req)
	if err != nil {
		fmt.Println("Error getting leaderboard")
	}
	defer resp.Body.Close()
	body, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Error reading response body.")
		return leaderboard, err
	}
	err = json.Unmarshal(body, &leaderboard)
	for k, mbr := range leaderboard.Members {
		mbr.LastStarTs, err = time.Parse("2006-01-02T15:04:05-0700", mbr.RawStarTs)
		leaderboard.Members[k] = mbr
	}
	return leaderboard, err
}

func writeToLog(d string) {
	f, err := os.OpenFile("statbot.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0664)
	if err != nil {
		panic(err)
	}
	f.WriteString(d)
	f.Close()
}