#include "sax_processor_builder.hh"

#include "processor.hh"
#include "sax_processor.hh"

#include <optional>
#include <utility>

namespace modxml {
namespace sax {

namespace {

class ProcessorBuilderImpl : public ProcessorBuilder {
 public:
  ProcessorBuilder* force_encoding(std::string const& str) override {
    force_encoding_ = str;
    return this;
  }

  ProcessorBuilder* custom_decoder_factory(
      std::shared_ptr<DecoderFactory> custom_decoder_factory) override {
    decoder_factory_ = std::move(custom_decoder_factory);
    return this;
  }

  ProcessorBuilder* set_default_buffer_size(std::size_t size) override {
    default_buffer_size_ = size;
    return this;
  }

  ProcessorBuilder* set_max_buffer_size(std::size_t size) override {
    max_buffer_size_ = size;
    return this;
  }

  std::unique_ptr<Processor> build(
      std::shared_ptr<Delegate> delegate) const override {
    return create_processor(std::move(delegate),
                            decoder_factory_,
                            force_encoding_,
                            default_buffer_size_,
                            max_buffer_size_);
  }

  ProcessorBuilderImpl() = default;

 private:
  std::shared_ptr<DecoderFactory> decoder_factory_;
  std::optional<std::string> force_encoding_;
  std::optional<std::size_t> default_buffer_size_;
  std::optional<std::size_t> max_buffer_size_;
};

}  // namespace

std::unique_ptr<ProcessorBuilder> ProcessorBuilder::create() {
  return std::make_unique<ProcessorBuilderImpl>();
}

}  // namespace sax
}  // namespace modxml