// llmongo.go
package main

import (
	"flag"
	"fmt"
	"github.com/fzzy/radix/redis"
	"gopkg.in/mgo.v2"
	"os"
	//    "gopkg.in/mgo.v2/bson"
	"bytes"
	"io/ioutil"
	"log"
	"path"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

type Options struct {
	RedisTTL    time.Duration
	CurrentPath string
	Exe         string
	LogFile     string
	PIDFile     string
	Version     bool
}

type Dbs struct {
	MongoUri string
	RedisUri string
	rdb      *redis.Client
	mdb      *mgo.Session
	ll       *mgo.Collection
}

type MongoLogin struct {
	User     string    `json:"user"`
	Protocol string    `json:"protocol"`
	Ip       string    `json:"ip"`
	Date     time.Time `json:"date"`
}

type Index struct {
	User string    `json:"user"`
	Date time.Time `json:"date"`
}

const (
	_VERSION = "v1.1.1"
)

var (
	opts = Options{
		RedisTTL: time.Hour * 11688, // 16 mesi
		LogFile:  "log/llmongo.log",
	}

	dbs = Dbs{
		MongoUri: "mongodb://127.0.0.1:27018",
		RedisUri: "127.0.0.1:6379",
	}
)

func usage() {
	fmt.Println("Usage: llmongo -m <mongo uri> -r <redis uri> -t <ttl> -l <logfile> -v\n")
	os.Exit(0)
}

func init() {
	var err error
	opts.CurrentPath, err = filepath.Abs(filepath.Dir(os.Args[0]))
	if err != nil {
		log.Fatal(err)
	}

	opts.LogFile = path.Join(opts.CurrentPath, opts.LogFile)
	opts.PIDFile = path.Join(opts.CurrentPath, "run", path.Base(os.Args[0])+".pid")
	opts.Exe = path.Base(os.Args[0])

	flag.StringVar(&dbs.MongoUri, "m", dbs.MongoUri, "Mongodb")
	flag.StringVar(&dbs.RedisUri, "r", dbs.RedisUri, "Redis")
	flag.StringVar(&opts.LogFile, "l", opts.LogFile, "Logs filename")
	flag.DurationVar(&opts.RedisTTL, "t", opts.RedisTTL, "Redis TTL")
	flag.BoolVar(&opts.Version, "v", false, "Version")
}

func (db *Dbs) connectRedis() {
	var err error
	db.rdb, err = redis.Dial("tcp", db.RedisUri)
	if err != nil {
		log.Println("Redis connect Error: ", err.Error())
		os.Exit(-1)
	}
}

func (db *Dbs) connectMongo() {
	var err error
	db.mdb, err = mgo.Dial(db.MongoUri)
	if err != nil {
		log.Println("Mongodb connect Error: ", err.Error())
		os.Exit(-3)
	}
	db.ll = db.mdb.DB("dovecot").C("lastlogin")
}

func checkPID(bpid []byte) bool {
	pid := strings.TrimRight(string(bpid), "\n")
	fmt.Println("PID: ", pid)
	bcmd, err := ioutil.ReadFile(path.Join("/proc", pid, "cmdline"))
	if err != nil {
		fmt.Println("cmdline error: ", err)
		return false
	}
	cmd := bytes.Trim(bcmd, "\x00")
	//	fmt.Println(string(cmd), opts.Exe)
	if strings.Contains(string(cmd), opts.Exe) {
		return true
	} else {
		fmt.Printf("PID %s used by %s\n", pid, cmd)
		return true
	}
	return true
}

func writePID(pfile string) {
	fpid, err := os.OpenFile(pfile, os.O_WRONLY|os.O_CREATE, 0666)
	if err != nil {
		fmt.Println("PID file error: ", err.Error())
		os.Exit(-5)
	}
	fpid.WriteString(strconv.Itoa(os.Getpid()))
	fpid.Close()
}

func main() {
	flag.Usage = usage
	flag.Parse()

	if opts.Version {
		fmt.Println(os.Args[0], _VERSION)
		os.Exit(0)
	}

	if bpid, err := ioutil.ReadFile(opts.PIDFile); err == nil && checkPID(bpid) {
		fmt.Println("Running: ", string(bpid))
		os.Exit(-6)
	} else {
		writePID(opts.PIDFile)
	}
	defer os.Remove(opts.PIDFile)

	//	fmt.Println(os.Stat(opts.PIDFile))

	fs, err := os.OpenFile(opts.LogFile, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
	if err != nil {
		fmt.Println("Log file error: ", err.Error())
		os.Exit(-4)
	}
	defer fs.Close()

	log.SetOutput(fs)
	//	log.SetPrefix("[llmongo] ")

	start := time.Now()
	fmt.Printf("Start: %+v\n", opts)
	log.Printf("Start: %+v\n", opts)

	dbs.connectRedis()
	defer dbs.rdb.Close()

	dbs.connectMongo()
	defer dbs.mdb.Close()

	//	// Estrae la lista degli utenti che hanno fatto login negli ultimi X min.
	//	llindex := opts.rdb.Cmd("smembers", "llindex")
	//	lista, err := llindex.List()
	//	if err != nil {
	//		log.Panicln("LLINDEX error: ", err.Error())
	//	}
	//		//	for _, user := range lista {
	//		// cicla fino a che esistono righe di login

	//	var wg sync.WaitGroup
	count := 0
	for {
		// estrae un userid dalla lista degli utenti che hanno fatto login
		spop := dbs.rdb.Cmd("spop", "llindex")
		user, err := spop.Str()
		log.Printf("SPOP: %+v %+v\n", spop, user)
		// se non ci sono piu' userid esce
		if err != nil {
			log.Printf("LLINDEX empty: %v\n", err)
			break
		}
		count++
		//		user := spop.String()
		var date int64
		var lastval, val string
		for {
			// Estrae l'ultimo login dell'utente 'user'
			val, err = dbs.rdb.Cmd("lindex", user, "-1").Str()
			if err != nil {
				log.Printf("LINDEX error: %+v\n", err)
				// se ha trovato user e righe di login
				if lastval != "" {
					// reinserisce l'ultimo login e imposta il ttl su Redis
					retval := dbs.rdb.Cmd("lpush", user, lastval)
					ttl := dbs.rdb.Cmd("expire", user, opts.RedisTTL.Seconds())
					log.Println("LPUSH retval: ", retval, ttl, user, lastval, opts.RedisTTL.Seconds())
				}
				break
			}
			// se la riga di login e' vuota
			if val == "" {
				log.Println("Login empty: ", user)
				retval := dbs.rdb.Cmd("lrem", user, "-1", val)
				log.Println("LREM retval: ", user, val, retval)
				continue
			}
			sval := strings.Split(val, ":")
			// se il formato della riga di login non e' corretto
			if sval[1] == "" {
				log.Println("Login format error: ", val, user)
				retval := dbs.rdb.Cmd("lrem", user, "-1", val)
				log.Println("LREM retval: ", user, val, retval)
				continue
			}
			// se il timestamp della riga di login non e' corretto
			date, err = strconv.ParseInt(sval[1], 10, 64)
			if err != nil {
				log.Printf("Date Error: %+v - %s\n", err, user)
				continue
			}
			ml := MongoLogin{
				User:     user,
				Protocol: sval[0],
				Ip:       sval[2],
				Date:     time.Unix(date, 0),
			}
			ind := Index{
				User: user,
				Date: time.Unix(date, 0),
			}
			// inserisce il login su Mongodb

			_, err := dbs.ll.Upsert(ind, ml)
			if err != nil {
				log.Printf("Insert error: %+v\n", err)
				// se l'errore non e' "duplicate key error" salta al prossimo senza cancellare niente
				if !strings.Contains(err.Error(), "E11000") {
					continue
				}
			}
			//				fmt.Println("Info: ", info)
			// cancella da Redis la riga di login inserita
			retval := dbs.rdb.Cmd("lrem", user, "-1", val)
			log.Println("LREM retval: ", retval, user, val)
			lastval = val
		}
		// controlla se ci sono ancora line di login per l'utente 'user'
		/*
			llen, _ := opts.rdb.Cmd("llen", user).Int64()
			if llen <= 1 {
				// elimina l'utente dalla lista di quelli che hanno fatto login se ci sono 1 o meno
				retval := opts.rdb.Cmd("srem", "llindex", user)
				log.Println("SREM retval: ", retval, user)
			}
		*/
	}

	fmt.Printf("Stop %v - %d\n", time.Since(start), count)
	log.Printf("Stop %v - %d\n", time.Since(start), count)
}