require "option_parser"


class OptionParser
	def to_s(io : IO)
		if banner = @banner
			io << banner
			io << "\n\n"
		end
		@flags.join io, "\n"
	end
end


def parsing_cli(authd_config : Baguette::Configuration::Auth)

	# frequently used functions
	opt_authd_login = -> (parser : OptionParser, authd_config : Baguette::Configuration::Auth) {
		parser.on "-l LOGIN", "--login LOGIN", "Authd user login." do |login|
			authd_config.login = login
			Baguette::Log.info "User login for authd: #{authd_config.login}."
		end
		parser.on "-p PASSWORD", "--password PASSWORD", "Authd user password." do |password|
			authd_config.pass = password
			Baguette::Log.info "User password for authd: #{authd_config.pass}."
		end
	}

	opt_help = -> (parser : OptionParser) {
		parser.on "-h", "--help", "Prints command usage." do
			puts "usage: #{PROGRAM_NAME} command -h"
			puts
			puts parser

			case Context.command
			when /admin-maintenance/
				Baguette::Log.warning "should provide subjects to request"
				Baguette::Log.warning "as in:"
				DNSManager::Request::Maintenance::Subject.names.each do |n|
					Baguette::Log.warning "- #{n}"
				end
			end

			exit 0
		end
	}

	# Unrecognized parameters are used to create commands with multiple arguments.
	# Example: user add _login email phone_
	# Here, login, email and phone are unrecognized arguments.
	# Still, the "user add" command expect them.
	unrecognized_args_to_context_args = -> (parser : OptionParser,
		nexact   : Int32?,
		at_least : Int32?) {

		# With the right args, these will be interpreted as serialized data.
		parser.unknown_args do |args|

			# either we test with the exact expected number of arguments or the least.
			if exact = nexact
				if args.size != exact
					Baguette::Log.error "#{parser}"
					exit 1
				end
			elsif least = at_least
				if args.size < least
					Baguette::Log.error "#{parser}"
					exit 1
				end
			else
				Baguette::Log.error "Number of parameters not even provided!"
				Baguette::Log.error "#{parser}"
				exit 1
			end

			args.each do |arg|
				Baguette::Log.debug "Unrecognized argument: #{arg} (adding to Context.args)"
				if Context.args.nil?
					Context.args = Array(String).new
				end
				Context.args.not_nil! << arg
			end
		end
	}

	parser = OptionParser.new do |parser|
		parser.banner = "Welcome on the DNSManager CLI administration."

		# Admin section.
		parser.on "admin", "Admin operations." do
			parser.banner = "Admin operations (requires secret via -k)."

			# Maintenance.
			parser.on("maintenance", "Maintenance operation of the website.") do
				Baguette::Log.info "maintenance operation of the website."
				Context.command = "admin-maintenance"
				parser.banner = "COMMAND: admin maintenance subject [value]"
				unrecognized_args_to_context_args.call parser, nil, 1
			end

			# Generate a zone file.
			parser.on("genzone", "Generate a zone file.") do
				Baguette::Log.info "generate a zone file on the server."
				Context.command = "admin-generate-zonefile"
				parser.banner = "COMMAND: admin genzone domain [domain…]"
				unrecognized_args_to_context_args.call parser, nil, 1
			end

			# Generate all zone files.
			parser.on("genall", "Generate all zone files.") do
				Baguette::Log.info "generate all zone files on the server."
				Context.command = "admin-generate-all-zonefiles"
				parser.banner = "COMMAND: admin genall"
				unrecognized_args_to_context_args.call parser, 0, nil
			end

		end

		# User section.
		parser.on "user", "Simple user operations." do
			parser.banner = "Operations as a simple user."

			# Domain.
			parser.on("domain", "Domain operations.") do
				parser.on("add", "Add a new domain.") do
					Baguette::Log.info "add domain."
					Context.command = "user-domain-add"
					parser.banner = "COMMAND: user domain add domain [domain...]"
					unrecognized_args_to_context_args.call parser, nil, 1
				end

				parser.on("del", "Delete a domain.") do
					Baguette::Log.info "del domain."
					Context.command = "user-domain-del"
					parser.banner = "COMMAND: user domain del domain [domain...]"
					unrecognized_args_to_context_args.call parser, nil, 1
				end

				parser.on("list", "List all domains.") do
					Baguette::Log.info "list domains."
					Context.command = "user-domain-list"
					parser.banner = "COMMAND: user domain list"
					unrecognized_args_to_context_args.call parser, 0, nil
				end
			end

			parser.on("zonefile", "Get a the generated zonefile.") do
				Baguette::Log.info "get a zone file."
				Context.command = "user-zonefile"
				parser.banner = "COMMAND: user zonefile domain [domain...]"
				unrecognized_args_to_context_args.call parser, nil, 1
			end

			# Zone.
			parser.on("zone", "Zone operations.") do
				parser.on("add", "Add new zone.") do
					Baguette::Log.info "add zone."
					Context.command = "user-zone-add"
					parser.banner = "COMMAND: user zone add <file> [<file>...]"
					unrecognized_args_to_context_args.call parser, nil, 1
				end

				parser.on("del", "Delete a zone (alias to domain del).") do
					Baguette::Log.info "del zone."
					Context.command = "user-domain-del"
					parser.banner = "COMMAND: user zone del domain [domain...]"
					unrecognized_args_to_context_args.call parser, nil, 1
				end

				parser.on("get", "Get a zone.") do
					Baguette::Log.info "get zone."
					Context.command = "user-zone-get"
					parser.banner = "COMMAND: user zone get domain [domain...]"
					unrecognized_args_to_context_args.call parser, nil, 1
				end

				parser.on("list", "List all domains (alias to domain list).") do
					Baguette::Log.info "list domains."
					Context.command = "user-domain-list"
					parser.banner = "COMMAND: user zone list"
					unrecognized_args_to_context_args.call parser, 0, nil
				end
			end

			parser.on("rr", "Zone Resource Record operations.") do
				parser.on("add", "Add new RR.") do
					Baguette::Log.info "Add RR."
					parser.banner = "COMMAND: user rr add [A|AAAA|CNAME|MX|SRV|TXT|NS]"
					parser.on("A", "Add new A RR.") do
						Baguette::Log.info "add new A RR."
						Context.command = "user-rr-add-a"
						parser.banner = "COMMAND: user rr add A <domain> <NAME> <TTL> <TARGET>"
						unrecognized_args_to_context_args.call parser, 4, nil
					end
				end

				parser.on("update", "Update a RR.") do
					Baguette::Log.info "Update a RR."
					parser.banner = "COMMAND: user rr update [A|AAAA|CNAME|MX|SRV|TXT|NS|SOA]"
					parser.on("A", "Update an A RR.") do
						Baguette::Log.info "update an A RR."
						Context.command = "user-rr-update-a"
						parser.banner = "COMMAND: user rr update A <domain> <rrid> <NAME> <TTL> <TARGET>"
						unrecognized_args_to_context_args.call parser, 5, nil
					end
				end

				parser.on("del", "Delete a RR.") do
					Baguette::Log.info "delete a RR."
					parser.banner = "COMMAND: user rr del <domain> <rrid>"
					Context.command = "user-rr-del"
					unrecognized_args_to_context_args.call parser, 2, nil
				end
			end

		end

		opt_help.call parser
	end

	parser.parse
end