package thinkgo

import (
	"container/list"
	"html/template"
	"net/http"

	"github.com/forgoer/thinkgo/context"
	"github.com/forgoer/thinkgo/router"
	"github.com/forgoer/thinkgo/think"
)

type Pipeline struct {
	handlers []think.Handler
	pipeline *list.List
	passable *context.Request
}

// Pipeline returns a new Pipeline
func NewPipeline() *Pipeline {
	p := &Pipeline{
		pipeline: list.New(),
	}
	return p
}

// Pipe Push a Middleware Handler to the pipeline
func (p *Pipeline) Pipe(m think.Handler) *Pipeline {
	p.pipeline.PushBack(m)
	return p
}

// Pipe Batch push Middleware Handlers to the pipeline
func (p *Pipeline) Through(hls []think.Handler) *Pipeline {
	for _, hl := range hls {
		p.Pipe(hl)
	}
	return p
}

// Passable set the request being sent through the pipeline.
func (p *Pipeline) Passable(passable *context.Request) *Pipeline {
	p.passable = passable
	return p
}

// Run run the pipeline
func (p *Pipeline) Run() interface{} {
	var result interface{}
	e := p.pipeline.Front()
	if e != nil {
		result = p.handler(p.passable, e)
	}
	return result
}

// ServeHTTP
func (p *Pipeline) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	request := context.NewRequest(r)
	request.CookieHandler = context.ParseCookieHandler()
	p.Passable(request)

	result := p.Run()

	switch result.(type) {
	case router.Response:
		result.(router.Response).Send(w)
		break
	case template.HTML:
		think.Html(string(result.(template.HTML))).Send(w)
		break
	case http.Handler:
		result.(http.Handler).ServeHTTP(w, r)
		break
	default:
		think.Response(result).Send(w)
		break
	}
}

func (p *Pipeline) handler(passable *context.Request, e *list.Element) interface{} {
	if e == nil {
		return nil
	}
	hl := e.Value.(think.Handler)
	result := hl.Process(passable, p.closure(e))
	return result
}

func (p *Pipeline) closure(e *list.Element) think.Closure {
	return func(req *context.Request) interface{} {
		e = e.Next()
		return p.handler(req, e)
	}
}