package pageHandler

import (
	"io"
	"mime/multipart"
	"net/http"
	"net/textproto"
	"strconv"
	"strings"
	"sync"
	"time"

	"golang.captainalm.com/mc-webserver/conf"
	"golang.captainalm.com/mc-webserver/pageHandler/utils"
)

const indexName = "index.go"

type PageHandler struct {
	PageContentsCache        map[string]*CachedPage
	PageProviders            map[string]PageProvider
	pageContentsCacheRWMutex *sync.RWMutex
	RangeSupported           bool
	CacheSettings            conf.CacheSettingsYaml
}

type CachedPage struct {
	Content     []byte
	ContentType string
	LastMod     time.Time
}

func NewPageHandler(config conf.ServeYaml) *PageHandler {
	var thePCCMap map[string]*CachedPage
	var theMutex *sync.RWMutex
	if config.CacheSettings.EnableContentsCaching {
		thePCCMap = make(map[string]*CachedPage)
		theMutex = &sync.RWMutex{}
	}
	toReturn := &PageHandler{
		PageContentsCache:        thePCCMap,
		pageContentsCacheRWMutex: theMutex,
		RangeSupported:           config.RangeSupported,
		CacheSettings:            config.CacheSettings,
	}
	if config.EnableGoInfoPage {
		toReturn.PageProviders = GetProviders(config.CacheSettings.EnableTemplateCaching, config.DataStorage, toReturn)
	} else {
		toReturn.PageProviders = GetProviders(config.CacheSettings.EnableTemplateCaching, config.DataStorage, nil)
	}
	return toReturn
}

func (ph *PageHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
	actualPagePath := ""
	if strings.HasSuffix(request.URL.Path, "/") {
		if strings.HasSuffix(request.URL.Path, ".go/") {
			actualPagePath = strings.TrimRight(request.URL.Path, "/")
		} else {
			actualPagePath = request.URL.Path + indexName
		}
	} else {
		actualPagePath = request.URL.Path
	}

	var currentProvider PageProvider
	canCache := false
	actualQueries := ""
	queryValues := request.URL.Query()
	var pageContent []byte
	pageContentType := ""
	var lastMod time.Time

	if currentProvider = ph.PageProviders[actualPagePath]; currentProvider != nil {
		actualQueries = currentProvider.GetCacheIDExtension(queryValues)

		if ph.CacheSettings.EnableContentsCaching {
			cached := ph.getPageFromCache(request.URL.Path, actualQueries)
			if cached != nil {
				pageContent = cached.Content
				pageContentType = cached.ContentType
				lastMod = cached.LastMod
			}
		}

		if pageContentType == "" {
			pageContentType, pageContent, canCache = currentProvider.GetContents(queryValues)
			lastMod = currentProvider.GetLastModified()
			if pageContentType != "" && canCache && ph.CacheSettings.EnableContentsCaching {
				ph.setPageToCache(request.URL.Path, actualQueries, &CachedPage{
					Content:     pageContent,
					ContentType: pageContentType,
					LastMod:     lastMod,
				})
			}
		}
	}

	allowedMethods := ph.getAllowedMethodsForPath(request.URL.Path)
	allowed := false
	if request.Method != http.MethodOptions {
		for _, method := range allowedMethods {
			if method == request.Method {
				allowed = true
				break
			}
		}
	}

	if allowed {

		if pageContentType == "" {
			utils.WriteResponseHeaderCanWriteBody(request.Method, writer, http.StatusNotFound, "Page Not Found")
		} else {

			switch request.Method {
			case http.MethodGet, http.MethodHead:

				writer.Header().Set("Content-Type", pageContentType)
				writer.Header().Set("Content-Length", strconv.Itoa(len(pageContent)))
				utils.SetLastModifiedHeader(writer.Header(), lastMod)
				utils.SetCacheHeaderWithAge(writer.Header(), ph.CacheSettings.MaxAge, lastMod)
				theETag := utils.GetValueForETagUsingByteArray(pageContent)
				writer.Header().Set("ETag", theETag)

				if utils.ProcessSupportedPreconditionsForNext(writer, request, lastMod, theETag, ph.CacheSettings.NotModifiedResponseUsingLastModified, ph.CacheSettings.NotModifiedResponseUsingETags) {

					httpRangeParts := utils.ProcessRangePreconditions(int64(len(pageContent)), writer, request, lastMod, theETag, ph.RangeSupported)
					if httpRangeParts != nil {
						if len(httpRangeParts) <= 1 {
							var theWriter io.Writer = writer
							if len(httpRangeParts) == 1 {
								theWriter = utils.NewPartialRangeWriter(theWriter, httpRangeParts[0])
							}
							_, _ = theWriter.Write(pageContent)
						} else {
							multWriter := multipart.NewWriter(writer)
							writer.Header().Set("Content-Type", "multipart/byteranges; boundary="+multWriter.Boundary())
							for _, currentPart := range httpRangeParts {
								mimePart, err := multWriter.CreatePart(textproto.MIMEHeader{
									"Content-Range": {currentPart.ToField(int64(len(pageContent)))},
									"Content-Type":  {"text/plain; charset=utf-8"},
								})
								if err != nil {
									break
								}
								_, err = mimePart.Write(pageContent[currentPart.Start : currentPart.Start+currentPart.Length])
								if err != nil {
									break
								}
							}
							_ = multWriter.Close()
						}
					}
				}
			case http.MethodDelete:
				ph.PurgeTemplateCache(actualPagePath, request.URL.Path == "/")
				ph.PurgeContentsCache(request.URL.Path, actualQueries)
				utils.SetNeverCacheHeader(writer.Header())
				utils.WriteResponseHeaderCanWriteBody(request.Method, writer, http.StatusOK, "")
			}
		}
	} else {

		theAllowHeaderContents := ""
		for _, method := range allowedMethods {
			theAllowHeaderContents += method + ", "
		}

		writer.Header().Set("Allow", strings.TrimSuffix(theAllowHeaderContents, ", "))
		if request.Method == http.MethodOptions {
			utils.WriteResponseHeaderCanWriteBody(request.Method, writer, http.StatusOK, "")
		} else {
			utils.WriteResponseHeaderCanWriteBody(request.Method, writer, http.StatusMethodNotAllowed, "")
		}
	}
}

func (ph *PageHandler) PurgeContentsCache(path string, query string) {
	if ph.CacheSettings.EnableContentsCaching && ph.CacheSettings.EnableContentsCachePurge {
		if path == "/" {
			ph.pageContentsCacheRWMutex.Lock()
			ph.PageContentsCache = make(map[string]*CachedPage)
			ph.pageContentsCacheRWMutex.Unlock()
		} else {
			if strings.HasSuffix(path, ".go/") {
				ph.pageContentsCacheRWMutex.RLock()
				toDelete := make([]string, len(ph.PageContentsCache))
				theSize := 0
				for cPath := range ph.PageContentsCache {
					dPath := strings.Split(cPath, "?")[0]
					if dPath == path || dPath == path[:len(path)-1] {
						toDelete[theSize] = cPath
						theSize++
					}
				}
				ph.pageContentsCacheRWMutex.RUnlock()
				ph.pageContentsCacheRWMutex.Lock()
				for i := 0; i < theSize; i++ {
					delete(ph.PageContentsCache, toDelete[i])
				}
				ph.pageContentsCacheRWMutex.Unlock()
				return
			} else if strings.HasSuffix(path, "/") {
				path += indexName
			}
			ph.pageContentsCacheRWMutex.Lock()
			if query == "" {
				delete(ph.PageContentsCache, path)
			} else {
				delete(ph.PageContentsCache, path+"?"+query)
			}
			ph.pageContentsCacheRWMutex.Unlock()
		}
	}
}

func (ph *PageHandler) PurgeTemplateCache(path string, all bool) {
	if ph.CacheSettings.EnableTemplateCaching && ph.CacheSettings.EnableTemplateCachePurge {
		if all {
			for _, pageProvider := range ph.PageProviders {
				pageProvider.PurgeTemplate()
			}
		} else {
			if pageProvider, ok := ph.PageProviders[path]; ok {
				pageProvider.PurgeTemplate()
			}
		}
	}
}
func (ph *PageHandler) getPageFromCache(pathIn string, cleanedQueries string) *CachedPage {
	ph.pageContentsCacheRWMutex.RLock()
	defer ph.pageContentsCacheRWMutex.RUnlock()
	if strings.HasSuffix(pathIn, ".go/") {
		return ph.PageContentsCache[strings.TrimRight(pathIn, "/")]
	} else if strings.HasSuffix(pathIn, "/") {
		pathIn += indexName
	}
	if cleanedQueries == "" {
		return ph.PageContentsCache[pathIn]
	} else {
		return ph.PageContentsCache[pathIn+"?"+cleanedQueries]
	}
}

func (ph *PageHandler) setPageToCache(pathIn string, cleanedQueries string, newPage *CachedPage) {
	ph.pageContentsCacheRWMutex.Lock()
	defer ph.pageContentsCacheRWMutex.Unlock()
	if strings.HasSuffix(pathIn, ".go/") {
		ph.PageContentsCache[strings.TrimRight(pathIn, "/")] = newPage
		return
	} else if strings.HasSuffix(pathIn, "/") {
		pathIn += indexName
	}
	if cleanedQueries == "" {
		ph.PageContentsCache[pathIn] = newPage
	} else {
		ph.PageContentsCache[pathIn+"?"+cleanedQueries] = newPage
	}
}

func (ph *PageHandler) getAllowedMethodsForPath(pathIn string) []string {
	if pathIn == "/" || strings.HasSuffix(pathIn, ".go/") {
		if (ph.CacheSettings.EnableTemplateCaching && ph.CacheSettings.EnableTemplateCachePurge) ||
			(ph.CacheSettings.EnableContentsCaching && ph.CacheSettings.EnableContentsCachePurge) {
			return []string{http.MethodHead, http.MethodGet, http.MethodOptions, http.MethodDelete}
		} else {
			return []string{http.MethodHead, http.MethodGet, http.MethodOptions}
		}
	} else {
		if ph.CacheSettings.EnableContentsCaching && ph.CacheSettings.EnableContentsCachePurge {
			return []string{http.MethodHead, http.MethodGet, http.MethodOptions, http.MethodDelete}
		} else {
			return []string{http.MethodHead, http.MethodGet, http.MethodOptions}
		}
	}
}

func (ph *PageHandler) GetRegisteredPages() []string {
	pages := make([]string, len(ph.PageProviders))
	index := 0
	for s := range ph.PageProviders {
		pages[index] = s
		index++
	}
	return pages
}

func (ph *PageHandler) GetCachedPages() []string {
	if ph.pageContentsCacheRWMutex == nil {
		return make([]string, 0)
	}
	ph.pageContentsCacheRWMutex.RLock()
	defer ph.pageContentsCacheRWMutex.RUnlock()
	pages := make([]string, len(ph.PageContentsCache))
	index := 0
	for s := range ph.PageContentsCache {
		pages[index] = s
		index++
	}
	return pages
}

func (ph *PageHandler) GetNumberOfCachedPages() int {
	if ph.pageContentsCacheRWMutex == nil {
		return 0
	}
	ph.pageContentsCacheRWMutex.RLock()
	defer ph.pageContentsCacheRWMutex.RUnlock()
	return len(ph.PageContentsCache)
}