// NewHTTP returns a new instance of the HTTPDrive struct.
func NewHTTP(before []DriveMiddleware, after []DriveMiddleware) *HTTPDrive {
	var drive HTTPDrive
	drive.TreeMux = httptreemux.New()
	drive.globalMW = LiftWM(before...)
	drive.globalMWAfter = LiftWM(after...)
	return &drive
}

func loadHttpTreeMux(routes []route) http.Handler {
	router := httptreemux.New()
	for _, route := range routes {
		router.Handle(route.method, route.path, httpTreeMuxHandler)
	}
	return router
}

// New create an Web value that handle a set of routes for the application.
// You can provide any number of middleware and they'll be used to wrap every
// request handler.
func New(mw ...Middleware) *Web {
	return &Web{
		TreeMux: httptreemux.New(),
		Ctx:     make(map[string]interface{}),
		mw:      mw,
	}
}

func buildApp(z *Zest) error {
	deps := usecases.DependencyDirectory.Get()

	store := infrastructure.NewGormStore()
	accountRepo := resources.NewAccountRepo(store)
	aclRepo := resources.NewAclRepo(store)
	sessionRepo := resources.NewSessionRepo(store)

	deps = append(
		deps,

		store,
		accountRepo,
		aclRepo,
		sessionRepo,
		httptreemux.New(),
		infrastructure.NewRender(),
		infrastructure.NewCacheStore(),
		usecases.NewPermissionCacheInter(accountRepo, aclRepo, infrastructure.NewCacheStore(), infrastructure.NewCacheStore()),
		usecases.NewSessionCacheInter(sessionRepo, infrastructure.NewLRUCacheStore(1024)),
		usecases.NewRouteDirectory,
		usecases.NewPermissionInter,
	)

	z.Injector.RegisterMultiple(deps)

	err := z.Injector.Populate()
	if err != nil {
		return err
	}

	return nil
}

// NewMux returns a Mux.
func NewMux() ServeMux {
	r := httptreemux.New()
	r.EscapeAddedRoutes = true
	return &mux{
		router:  r,
		handles: make(map[string]MuxHandler),
	}
}

// New creates a new Router and returns it
func New() *Router {
	r := &Router{}
	r.index = make(map[string]string)
	r.prefix = "/"
	r.router = httptreemux.New()
	r.router.NotFoundHandler = http.HandlerFunc(r.notFoundHandler)

	return r
}

func (s *Server) Init() {

	s.logger = log.New(os.Stdout, "[GoWebApp] ", 0)
	mainController := controllers.NewMainController()

	s.router = httptreemux.New()
	s.router.GET("/", mainController.GetHandler)
	s.router.GET("/_version", mainController.GetVersionHandler)

	s.httpServer = negroni.Classic()
	s.httpServer.UseHandler(s.router)
}

func (s *Server) initRoutes() {
	s.router = httptreemux.New()
	s.router.GET("/", s.healthCheck)
	s.router.GET("/healthcheck", s.healthCheck)

	s.router.POST("/api/item-schemas", transaction.Handle(s.createItemSchema))
	s.router.GET("/api/item-schemas", transaction.Handle(s.findItemSchema))
	s.router.GET("/api/item-schemas/findOne", transaction.Handle(s.findOneItemSchema))
	s.router.GET("/api/item-schemas/:collectionName", transaction.Handle(s.findItemSchemaByCollectionName))
	s.router.DELETE("/api/item-schemas/:collectionName", transaction.Handle(s.deleteItemSchemaByCollectionName))

	s.router.POST("/api/:collectionName", s.createResource)
	s.router.GET("/api/:collectionName", s.findResource)
	s.router.GET("/api/:collectionName/findOne", s.findOneResource)
	s.router.GET("/api/:collectionName/:resourceId", s.findResourceById)
	s.router.DELETE("/api/:collectionName/:resourceId", s.deleteResourceById)
}

func main() {
	// get config var
	port := envMustGet("JUNO_PORT")
	murl := envMustGet("JUNO_MONGO_URL")

	// initialize mongo
	s := storage.MgoMustConnect(murl)
	defer s.Close()

	// controller have to work with storage
	c := controller.New(s)

	// init router. httptreemux is fast and convinient
	r := httptreemux.New()

	// some of the endpoints are available in anonymous mode and some of them aren't.
	// we can perform different middleware operations - with auth checks and without.

	// build middleware that creates context and pass it to handlers
	rc := middle.Context(r, s)
	// add version
	rc = middle.Version(rc, VER)
	rc.Handle("POST", "/user", c.UserCreate)
	rc.Handle("GET", "/user/:userid/confirm", c.UserConfirm)

	rc.Handle("GET", "/profile/:profid", c.ProfileGet)
	rc.Handle("GET", "/profile/all", c.ProfileAll)

	// Add middleware that checks authentication.
	ra := middle.Authentication(rc, s)
	ra.Handle("PUT", "/profile", c.ProfileUpdate)
	ra.Handle("GET", "/profile/:profid/history", c.ProfileHistory)

	// add middleware that decorates router and checks that Content-Type is application/json
	rj := middle.JSONContentType(r)

	// Fire up the server
	log.Panic(http.ListenAndServe("localhost:"+port, rj))
}

func loadHttpTreeMuxSingle(method, path string, handler httptreemux.HandlerFunc) http.Handler {
	router := httptreemux.New()
	router.Handle(method, path, handler)
	return router
}

// NewMux returns a Mux.
func NewMux() ServeMux {
	return &mux{
		router:  httptreemux.New(),
		handles: make(map[string]MuxHandler),
	}
}

// New create an App value that handle a set of routes for the application.
// You can provide any number of middleware and they'll be used to wrap every
// request handler.
func New(mw ...Middleware) *App {
	return &App{
		TreeMux: httptreemux.New(),
		mw:      mw,
	}
}

func starthttpTreeMux() {
	mux := httptreemux.New()
	mux.GET("/hello", httpTreeMuxHandler)
	http.ListenAndServe(":"+strconv.Itoa(port), mux)
}

// New create an App value that handle a set of routes for the application.
func New() *App {
	return &App{
		TreeMux: httptreemux.New(),
	}
}

func main() {
	// Setup
	var err error

	// GOMAXPROCS - Maybe not needed
	runtime.GOMAXPROCS(runtime.NumCPU())

	// Write log to file if the log flag was provided
	if flags.Log != "" {
		logFile, err := os.OpenFile(flags.Log, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
		if err != nil {
			log.Fatal("Error: Couldn't open log file: " + err.Error())
		}
		defer logFile.Close()
		log.SetOutput(logFile)
	}

	// Configuration is read from config.json by loading the configuration package

	// Database
	err = database.Initialize()
	if err != nil {
		log.Fatal("Error: Couldn't initialize database:", err)
		return
	}

	// Global blog data
	err = methods.GenerateBlog()
	if err != nil {
		log.Fatal("Error: Couldn't generate blog data:", err)
		return
	}

	// Templates
	err = templates.Generate()
	if err != nil {
		log.Fatal("Error: Couldn't compile templates:", err)
		return
	}

	// Plugins
	err = plugins.Load()
	if err == nil {
		// Close LuaPool at the end
		defer plugins.LuaPool.Shutdown()
		log.Println("Plugins loaded.")
	}

	// HTTP(S) Server
	httpPort := configuration.Config.HttpHostAndPort
	httpsPort := configuration.Config.HttpsHostAndPort
	// Check if HTTP/HTTPS flags were provided
	if flags.HttpPort != "" {
		components := strings.SplitAfterN(httpPort, ":", 2)
		httpPort = components[0] + flags.HttpPort
	}
	if flags.HttpsPort != "" {
		components := strings.SplitAfterN(httpsPort, ":", 2)
		httpsPort = components[0] + flags.HttpsPort
	}
	// Determine the kind of https support (as set in the config.json)
	switch configuration.Config.HttpsUsage {
	case "AdminOnly":
		checkHttpsCertificates()
		httpRouter := httptreemux.New()
		httpsRouter := httptreemux.New()
		// Blog and pages as http
		server.InitializeBlog(httpRouter)
		server.InitializePages(httpRouter)
		// Blog and pages as https
		server.InitializeBlog(httpsRouter)
		server.InitializePages(httpsRouter)
		// Admin as https and http redirect
		// Add redirection to http router
		httpRouter.GET("/admin/", httpsRedirect)
		httpRouter.GET("/admin/*path", httpsRedirect)
		// Add routes to https router
		server.InitializeAdmin(httpsRouter)
		// Start https server
		log.Println("Starting https server on port " + httpsPort + "...")
		go func() {
			err := http.ListenAndServeTLS(httpsPort, filenames.HttpsCertFilename, filenames.HttpsKeyFilename, httpsRouter)
			if err != nil {
				log.Fatal("Error: Couldn't start the HTTPS server:", err)
			}
		}()
		// Start http server
		log.Println("Starting http server on port " + httpPort + "...")
		err := http.ListenAndServe(httpPort, httpRouter)
		if err != nil {
			log.Fatal("Error: Couldn't start the HTTP server:", err)
		}
	case "All":
		checkHttpsCertificates()
		httpsRouter := httptreemux.New()
		httpRouter := httptreemux.New()
		// Blog and pages as https
		server.InitializeBlog(httpsRouter)
		server.InitializePages(httpsRouter)
		// Admin as https
//.........这里部分代码省略.........

//NewEndPoints creates new prefixed endpoints
func NewEndPoints(not *notifier.Notifier, store *sqlstore.Store, convs feeder.Conventions, cfg config.Rest, org config.Internships) EndPoints {
	ed := EndPoints{
		store:        store,
		router:       httptreemux.New(),
		prefix:       strings.TrimSuffix(cfg.Prefix, "/"),
		cfg:          cfg,
		organization: org,
		conventions:  convs,
		notifier:     not,
	}
	ed.router.NotFoundHandler = func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "", http.StatusNotFound)
	}
	//Set the endpoints
	ed.get("/users/", users)
	ed.post("/users/", newUser)
	ed.post("/users/:u/email", setEmail)
	ed.post("/users/:u/person", setUserPerson)
	ed.post("/users/:u/role", setUserRole)
	ed.del("/users/:u", delUser)
	ed.get("/users/:u", user)
	ed.del("/users/:u/session", ed.delSession)
	ed.post("/students/:s/major", setMajor)
	ed.post("/students/:s/promotion", setPromotion)
	ed.post("/students/:s/male", setMale)
	ed.post("/students/:s/alumni", setAlumni)
	ed.post("/students/:s/skip", setStudentSkippable)
	ed.get("/students/", students)
	ed.post("/students/", newStudent)

	ed.router.GET(ed.prefix+"/internships/", ed.anon(internships))
	ed.get("/internships/:s", internship)
	ed.post("/internships/:s/company", setCompany)
	ed.post("/internships/:s/supervisor", setSupervisor)
	ed.post("/internships/:s/tutor", setTutor)
	ed.del("/internships/:s/defense", rmDefense)
	ed.post("/internships/:s/defense", setStudentDefense)
	ed.put("/internships/:s/defense", updateStudentDefense)
	ed.get("/internships/:s/defense", studentDefense)
	ed.post("/internships/:s/defense/grade", setDefenseGrade)
	ed.post("/internships/", ed.newInternship)

	ed.del("/surveys/:s/:k", resetSurvey)
	ed.post("/surveys/:s/:k", requestSurvey)
	ed.get("/reports/:s/:k/", report)
	ed.get("/reports/:s/:k/content", reportContent)
	ed.post("/reports/:s/:k/content", setReportContent)
	ed.post("/reports/:s/:k/deadline", setReportDeadline)
	ed.post("/reports/:s/:k/grade", setReportGrade)
	ed.post("/reports/:s/:k/private", setReportPrivacy)

	ed.get("/conventions/", conventions)
	ed.get("/conventions/:s", convention)

	ed.get("/logs/:k", streamLog)
	ed.get("/logs/", logs)

	ed.get("/defenses/", defenseSessions)
	ed.post("/defenses/", newDefenseSession)
	ed.get("/defenses/:id/:r/", defenseSession)
	ed.del("/defenses/:id/:r", rmDefenseSession)
	ed.post("/defenses/:id/:r/jury/", newDefenseSessionJury)
	ed.del("/defenses/:id/:r/jury/:j", rmDefenseSessionJury)

	ed.router.GET(ed.prefix+"/program/", ed.anon(ed.program))
	ed.router.POST(ed.prefix+"/signin", ed.anon(ed.signin))
	ed.router.POST(ed.prefix+"/resetPassword", ed.anon(ed.resetPassword))
	ed.router.POST(ed.prefix+"/newPassword", ed.anon(ed.newPassword))
	ed.router.GET(ed.prefix+"/config", ed.anon(ed.config))
	ed.router.GET(ed.prefix+"/surveys/:t", ed.anon(ed.survey))
	ed.router.POST(ed.prefix+"/surveys/:t", ed.anon(ed.setSurvey))
	return ed
}