package components

import (
	"errors"
	"fmt"
	"strings"
)

type Server struct {
	Comment          string
	Listens          []*ServerListen
	Directives       []IDirective
	Line             int
	Cors             bool
	AllowMethods     string
	AllowHeaders     string
	AllowOrigins     string
	AllowCredentials bool
	Preflight        bool
}

func (s *Server) GetCodeBlock() string {
	return ""
}

func NewServer(directive IDirective) (*Server, error) {
	server := &Server{}
	if block := directive.GetBlock(); block != nil {
		server.Line = directive.GetBlock().GetLine()
		server.Comment = block.GetComment()
		directives := block.GetDirectives()
		for _, dir := range directives {
			switch dir.GetName() {
			case "listen":
				server.Listens = append(server.Listens, NewServerListen(dir.GetParameters(), dir.GetLine()))
			case "add_header":
				params := dir.GetParameters()
				if params[0] == "Access-Control-Allow-Origin" {
					server.Cors = true
					server.AllowOrigins = params[1]
				}
				if params[0] == "Access-Control-Allow-Methods" {
					server.AllowMethods = params[1]
				}
				if params[0] == "Access-Control-Allow-Headers" {
					server.AllowHeaders = params[1]
				}
				if params[0] == "Access-Control-Allow-Credentials" && params[1] == "true" {
					server.AllowCredentials = true
				}
				server.Directives = append(server.Directives, dir)
			case "if":
				params := dir.GetParameters()
				if params[0] == "(" && params[1] == "$request_method" && params[2] == `=` && params[3] == `'OPTIONS'` && params[4] == ")" {
					server.Preflight = true
				}
				server.Directives = append(server.Directives, dir)
			default:
				server.Directives = append(server.Directives, dir)
			}
		}
		return server, nil
	}
	return nil, errors.New("server directive must have a block")
}

func (s *Server) GetName() string {
	return "server"
}

func (s *Server) GetParameters() []string {
	return []string{}
}

func (s *Server) GetBlock() IBlock {
	return s
}

func (s *Server) GetComment() string {
	return s.Comment
}

func (s *Server) GetDirectives() []IDirective {
	directives := make([]IDirective, 0)
	for _, ls := range s.Listens {
		directives = append(directives, ls)
	}
	directives = append(directives, s.Directives...)
	return directives
}

func (s *Server) FindDirectives(directiveName string) []IDirective {
	directives := make([]IDirective, 0)
	for _, directive := range s.Directives {
		if directive.GetName() == directiveName {
			directives = append(directives, directive)
		}
		if directive.GetBlock() != nil {
			directives = append(directives, directive.GetBlock().FindDirectives(directiveName)...)
		}
	}
	if directiveName == "listen" {
		for _, listen := range s.Listens {
			params := []string{listen.Bind}
			params = append(params, listen.Parameters...)
			if listen.DefaultServer != "" {
				params = append(params, DefaultServer)
			}
			directives = append(directives, &Directive{
				Name:       "listen",
				Parameters: params,
			})
		}
	}
	return directives
}

func (s *Server) UpdateDirective(key string, params []string) {
	if key == "" || len(params) == 0 {
		return
	}
	if key == "listen" {
		defaultServer := false
		paramLen := len(params)
		if paramLen > 0 && params[paramLen-1] == "default_server" {
			params = params[:paramLen-1]
			defaultServer = true
		}
		s.UpdateListen(params[0], defaultServer, params[1:]...)
		return
	}

	directives := s.Directives
	index := -1
	for i, dir := range directives {
		if dir.GetName() == key {
			if IsRepeatKey(key) {
				oldParams := dir.GetParameters()
				if !(len(oldParams) > 0 && oldParams[0] == params[0]) {
					continue
				}
			}
			index = i
			break
		}
	}
	newDirective := &Directive{
		Name:       key,
		Parameters: params,
	}
	if index > -1 {
		directives[index] = newDirective
	} else {
		directives = append(directives, newDirective)
	}
	s.Directives = directives
}

func (s *Server) RemoveDirective(key string, params []string) {
	directives := s.Directives
	var newDirectives []IDirective
	for _, dir := range directives {
		if dir.GetName() == key {
			if len(params) == 0 {
				continue
			}
			oldParams := dir.GetParameters()
			if key == "location" {
				if len(params) == len(oldParams) {
					exist := true
					for i := range params {
						if params[i] != oldParams[i] {
							exist = false
							break
						}
					}
					if exist {
						continue
					}
				}
			} else {
				if oldParams[0] == params[0] {
					continue
				}
			}
		}
		newDirectives = append(newDirectives, dir)
	}
	s.Directives = newDirectives
}

func (s *Server) GetLine() int {
	return s.Line
}

func (s *Server) AddListen(bind string, defaultServer bool, params ...string) {
	listen := &ServerListen{
		Bind:       bind,
		Parameters: params,
	}
	if defaultServer {
		listen.DefaultServer = DefaultServer
	}
	s.Listens = append(s.Listens, listen)
}

func isSameArray(arr1, arr2 []string) bool {
	set1 := make(map[string]struct{})
	for _, v := range arr1 {
		set1[v] = struct{}{}
	}
	for _, v := range arr2 {
		if _, exists := set1[v]; !exists {
			return false
		}
	}
	return true
}

func (s *Server) UpdateListen(bind string, defaultServer bool, params ...string) {
	listen := &ServerListen{
		Bind:       bind,
		Parameters: params,
	}
	if defaultServer {
		listen.DefaultServer = DefaultServer
	}
	var newListens []*ServerListen
	exist := false
	for _, li := range s.Listens {
		if li.Bind == bind && isSameArray(li.Parameters, params) {
			exist = true
			newListens = append(newListens, listen)
		} else {
			newListens = append(newListens, li)
		}
	}
	if !exist {
		newListens = append(newListens, listen)
	}

	s.Listens = newListens
}

func (s *Server) DeleteListen(bind string) {
	var newListens []*ServerListen
	for _, li := range s.Listens {
		if li.Bind != bind {
			newListens = append(newListens, li)
		}
	}
	s.Listens = newListens
}

func (s *Server) RemoveListen(bind string, params ...string) {
	var newListens []*ServerListen
	for _, li := range s.Listens {
		if li.Bind == bind && isSameArray(li.Parameters, params) {
			continue
		}
		newListens = append(newListens, li)
	}
	s.Listens = newListens
}

func (s *Server) DeleteServerName(name string) {
	var names []string
	dirs := s.FindDirectives("server_name")
	params := dirs[0].GetParameters()
	for _, param := range params {
		if param != name {
			names = append(names, param)
		}
	}
	s.UpdateServerName(names)
}

func (s *Server) AddServerName(name string) {
	dirs := s.FindDirectives("server_name")
	params := dirs[0].GetParameters()
	params = append(params, name)
	s.UpdateServerName(params)
}

func (s *Server) UpdateServerName(names []string) {
	s.UpdateDirective("server_name", names)
}

func (s *Server) UpdateRoot(path string) {
	s.UpdateDirective("root", []string{path})
}

func (s *Server) UpdateRootProxyForAi(proxy []string) {
	newDir := Directive{
		Name:       "location",
		Parameters: []string{"/"},
		Block:      &Block{},
	}
	block := &Block{}
	block.AppendDirectives(
		&Directive{
			Name: "proxy_buffering",
			Parameters: []string{
				"off",
			},
		},
		&Directive{
			Name: "proxy_cache",
			Parameters: []string{
				"off",
			},
		},
		&Directive{
			Name: "proxy_http_version",
			Parameters: []string{
				"1.1",
			},
		},
		&Directive{
			Name: "proxy_set_header",
			Parameters: []string{
				"Connection", "''",
			},
		},
		&Directive{
			Name: "chunked_transfer_encoding",
			Parameters: []string{
				"off",
			},
		},
		&Directive{
			Name:       "proxy_pass",
			Parameters: proxy,
		},
	)

	newDir.Block = block
	s.UpdateDirectiveBySecondKey("location", "/", newDir)
}

func (s *Server) UpdateRootLocation() {
	newDir := Directive{
		Name:       "location",
		Parameters: []string{"/"},
		Block:      &Block{},
	}
	block := &Block{}
	block.AppendDirectives(&Directive{
		Name:       "root",
		Parameters: []string{"index.html"},
	})
	newDir.Block = block
}

func (s *Server) UpdateRootProxy(proxy []string) {
	httpsProxy := len(proxy) > 0 && strings.HasPrefix(strings.ToLower(strings.TrimSpace(proxy[0])), "https://")
	newDir := Directive{
		Name:       "location",
		Parameters: []string{"/"},
		Block:      &Block{},
	}
	block := &Block{}

	block.AppendDirectives(
		&Directive{
			Name:       "proxy_set_header",
			Parameters: []string{"Host", "$host"},
		},
		&Directive{
			Name:       "proxy_set_header",
			Parameters: []string{"X-Forwarded-For", "$proxy_add_x_forwarded_for"},
		},
		&Directive{
			Name:       "proxy_set_header",
			Parameters: []string{"X-Forwarded-Host", "$server_name"},
		},
		&Directive{
			Name:       "proxy_set_header",
			Parameters: []string{"X-Real-IP", "$remote_addr"},
		},
		&Directive{
			Name:       "proxy_set_header",
			Parameters: []string{"X-Forwarded-Proto", "$scheme"},
		},
		&Directive{
			Name:       "proxy_set_header",
			Parameters: []string{"Connection", "upgrade"},
		},
		&Directive{
			Name:       "proxy_set_header",
			Parameters: []string{"Upgrade", "$http_upgrade"},
		},
		&Directive{
			Name:       "proxy_http_version",
			Parameters: []string{"1.1"},
		},
		&Directive{
			Name:       "proxy_ssl_server_name",
			Parameters: []string{map[bool]string{true: "on", false: "off"}[httpsProxy]},
		},
		&Directive{
			Name:       "proxy_ssl_name",
			Parameters: []string{"$proxy_host"},
		},
		&Directive{
			Name:       "proxy_pass",
			Parameters: proxy,
		},
	)

	newDir.Block = block
	s.UpdateDirectiveBySecondKey("location", "/", newDir)
}

func (s *Server) UpdatePHPProxy(proxy []string, localPath string) {
	newDir := Directive{
		Name:       "location",
		Parameters: []string{"~ [^/]\\.php(/|$)"},
		Block:      &Block{},
	}
	block := &Block{}
	block.AppendDirectives(
		&Directive{
			Name:       "fastcgi_pass",
			Parameters: proxy,
		},
		&Directive{
			Name:       "include",
			Parameters: []string{"fastcgi-php.conf"},
		},
		&Directive{
			Name:       "include",
			Parameters: []string{"fastcgi_params"},
		},
	)
	if localPath == "" {
		block.AppendDirectives(&Directive{
			Name:       "set",
			Parameters: []string{"$real_script_name", "$fastcgi_script_name"},
		})
		ifDir := &Directive{
			Name:       "if",
			Parameters: []string{"($fastcgi_script_name ~ \"^(.+?\\.php)(/.+)$\")"},
		}
		ifDir.Block = &Block{
			Directives: []IDirective{
				&Directive{
					Name:       "set",
					Parameters: []string{"$real_script_name", "$1"},
				},
				&Directive{
					Name:       "set",
					Parameters: []string{"$path_info", "$2"},
				},
			},
		}
		block.AppendDirectives(
			ifDir,
			&Directive{
				Name:       "fastcgi_param",
				Parameters: []string{"SCRIPT_FILENAME", "$document_root$real_script_name"},
			},
			&Directive{
				Name:       "fastcgi_param",
				Parameters: []string{"SCRIPT_NAME", "$real_script_name"},
			},
			&Directive{
				Name:       "fastcgi_param",
				Parameters: []string{"PATH_INFO", "$path_info"},
			})

	} else {
		block.AppendDirectives(&Directive{
			Name:       "fastcgi_param",
			Parameters: []string{"SCRIPT_FILENAME", localPath},
		})
	}
	newDir.Block = block
	s.UpdateDirectiveBySecondKey("location", "~ [^/]\\.php(/|$)", newDir)
}

func (s *Server) UpdateDirectiveBySecondKey(name string, key string, directive Directive) {
	directives := s.Directives
	index := -1
	for i, dir := range directives {
		if dir.GetName() == name && dir.GetParameters()[0] == key {
			index = i
			break
		}
	}
	if index > -1 {
		directives[index] = &directive
	} else {
		directives = append(directives, &directive)
	}
	s.Directives = directives
}

func (s *Server) RemoveListenByBind(bind string) {
	var listens []*ServerListen
	for _, listen := range s.Listens {
		if listen.Bind != bind {
			listens = append(listens, listen)
		}
	}
	s.Listens = listens
}

func (s *Server) AddHTTP2HTTPS(httpsPort int) {
	newDir := Directive{
		Name:       "if",
		Parameters: []string{"($scheme = http)"},
		Block:      &Block{},
	}
	block := &Block{}
	if httpsPort == 443 {
		block.AppendDirectives(&Directive{
			Name:       "return",
			Parameters: []string{"301", "https://$host$request_uri"},
		})
	} else {
		block.AppendDirectives(&Directive{
			Name:       "return",
			Parameters: []string{"301", fmt.Sprintf("https://$host:%d$request_uri", httpsPort)},
		})
	}

	newDir.Block = block
	s.UpdateDirectiveBySecondKey("if", "($scheme", newDir)
}

func (s *Server) UpdateAllowIPs(ips []string) {
	index := -1
	for i, directive := range s.Directives {
		if directive.GetName() == "location" && directive.GetParameters()[0] == "/" {
			index = i
			break
		}
	}
	ipDirectives := make([]IDirective, 0)
	for _, ip := range ips {
		ipDirectives = append(ipDirectives, &Directive{
			Name:       "allow",
			Parameters: []string{ip},
		})
	}
	ipDirectives = append(ipDirectives, &Directive{
		Name:       "deny",
		Parameters: []string{"all"},
	})
	if index != -1 {
		newDirectives := append(ipDirectives, s.Directives[index:]...)
		s.Directives = append(s.Directives[:index], newDirectives...)
	} else {
		s.Directives = append(s.Directives, ipDirectives...)
	}
}

func (s *Server) AddCorsOption() {
	newDir := &Directive{
		Name:       "if",
		Parameters: []string{"(", "$request_method", "=", "'OPTIONS'", ")"},
		Block:      &Block{},
	}
	block := &Block{}
	block.AppendDirectives(&Directive{
		Name:       "return",
		Parameters: []string{"204"},
	})
	newDir.Block = block
	directives := s.GetDirectives()
	newDirectives := make([]IDirective, 0)
	for _, dir := range directives {
		if dir.GetName() != "listen" {
			newDirectives = append(newDirectives, dir)
		}
	}
	newDirectives = append(newDirectives, newDir)
	s.Directives = newDirectives
}
