package main

import (
	"fmt"
	C "git.oschina.net/yyzybb537/Xedis/command"
	I "git.oschina.net/yyzybb537/Xedis/interfaces"
	P "git.oschina.net/yyzybb537/Xedis/proto"
	T "git.oschina.net/yyzybb537/Xedis/transfer"
	V "git.oschina.net/yyzybb537/Xedis/view"
	S "git.oschina.net/yyzybb537/Xedis/structures"
	O "git.oschina.net/yyzybb537/Xedis/option"
	CTL "git.oschina.net/yyzybb537/Xedis/control"
	log "github.com/yyzybb537/glog"
	"io"
	"os"
	"runtime"
	"time"
	"net/http"
	_ "net/http/pprof"
	"runtime/pprof"
)

var _ = V.Dummy
var _ = S.Dummy
var _ = O.Dummy
var _ = CTL.Dummy

var transfer T.Transfer
var view I.View

func onRead(buf []byte, w I.BufferedConn) (bytesConsume int, err error) {
	var c *C.Command
	var n int

	for {
		readBuf := buf[bytesConsume:]
		c, n, err = P.GProto.UnmarshalRequest(readBuf)
		if err != nil {
			if err == io.EOF {
				err = nil
				break
			} else if n == 0 {
				break
			}
		}
		bytesConsume += n

		if err != nil {
			w.Write(P.GProto.MarshalError(err))
			err = nil
			continue
		}

		//log.Infof("Handle Command(%s) %s.", c.Type.Structure, c.String())
		c.From = w
		c.Origin = readBuf[:n]
		if !c.Type.ReadOnly && CTL.GetSyncMgr().IsReadOnly() {
			c.Err = fmt.Errorf("READONLY You can't write against a read only slave.")
		} else {
			CTL.HandleCommand(c)
		}

		if !c.Type.NoReply {
			resp := P.GProto.MarshalResponse(c)
			//log.Infof("Response(%s) %s.", c.Type.Structure, string(resp[:len(resp) - 1]))
			w.Write(resp)
		}
	}

	//log.Infof("onRead ret bytesConsume:%d, err:%v", bytesConsume, err)
	return
}

func main() {
	if err := CTL.GetServerConfig().InitFlags(); err != nil {
		log.Errorf("Configure init error:%s", err.Error())
		return 
    }

	if CTL.GetServerConfig().RuntimeConfig.Procs > 0 {
		runtime.GOMAXPROCS(CTL.GetServerConfig().RuntimeConfig.Procs)
	}

	if CTL.GetServerConfig().DebugConfig.IsProf {
		log.Infof("Listen performance http service at %s", CTL.GetServerConfig().DebugConfig.ProfAddress)
		go func() {
			log.Info(http.ListenAndServe(CTL.GetServerConfig().DebugConfig.ProfAddress, nil))
		}()
    }

	if CTL.GetServerConfig().DebugConfig.HeapProfile != "" {
		go func() {
			time.Sleep(time.Second * 10)
			f, err := os.Create(CTL.GetServerConfig().DebugConfig.HeapProfile)
			if err != nil {
				log.Fatal(err)
			}

			pprof.WriteHeapProfile(f)
			f.Close()
			log.Infof("Dump Heap Profile.")
		}()
	}

	errList := C.GetRegisterErr()
	if len(errList) > 0 {
		for _, v := range errList {
			log.Errorf("Error:%s", v)
		}
		return
	}

	if CTL.GetServerConfig().IsDump() {
		// dump all commands
		fmt.Println(C.DumpCommands())
		fmt.Println(P.DumpProtos())
		fmt.Println(I.DumpViews())
		fmt.Println(T.DumpTransfers())
		return
	}

	P.GProto = P.CreateProto(CTL.GetServerConfig().CustomConfig.ProtoName)
	if P.GProto == nil {
		log.Errorf("No support proto name:%s", CTL.GetServerConfig().CustomConfig.ProtoName)
		return
	}

	transfer = T.CreateTransfer(CTL.GetServerConfig().CustomConfig.TransferName)
	if transfer == nil {
		log.Errorf("No support transfer name:%s", CTL.GetServerConfig().CustomConfig.TransferName)
		return
	}

	view = I.CreateView(CTL.GetServerConfig().CustomConfig.ViewName)
	if view == nil {
		log.Errorf("No support view name:%s", CTL.GetServerConfig().CustomConfig.ViewName)
		return
	}
	I.InitView(view)

	err := CTL.GetDBManager().Init()
	if err != nil {
		log.Errorf("Startup, init DB error: %s", err.Error())
		return
	}

	err = transfer.Listen(CTL.GetServerConfig().RuntimeConfig.Listen, onRead)
	if err != nil {
		log.Errorf("Startup error: %s", err.Error())
		return
	}

	log.Infof("Configure:\n%s", CTL.GetServerConfig().DumpConfig())
	log.Infof("Xedis Startup")
	c := make(chan bool, 0)
	<-c
}