// Copyright 2018 The Amber Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SRC_AMBERSCRIPT_PARSER_H_
#define SRC_AMBERSCRIPT_PARSER_H_

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "amber/result.h"
#include "src/parser.h"
#include "src/script.h"

namespace amber {

class Tokenizer;
class Token;

namespace amberscript {

/// Parser for the `AmberScript` format.
class Parser : public amber::Parser {
 public:
  Parser();
  explicit Parser(Delegate* delegate);
  ~Parser() override;

  // amber::Parser
  Result Parse(const std::string& data) override;

 private:
  std::string make_error(const std::string& err);
  Result ToShaderType(const std::string& str, ShaderType* type);
  Result ToBufferType(const std::string& str, BufferType* type);
  Result ToShaderFormat(const std::string& str, ShaderFormat* fmt);
  Result ToPipelineType(const std::string& str, PipelineType* type);
  Result ValidateEndOfStatement(const std::string& name);

  Result ParseStruct();
  Result ParseBuffer();
  Result ParseImage();
  Result ParseBufferInitializer(Buffer*);
  Result ParseBufferInitializerSize(Buffer*);
  Result ParseBufferInitializerFill(Buffer*, uint32_t);
  Result ParseBufferInitializerSeries(Buffer*, uint32_t);
  Result ParseBufferInitializerData(Buffer*);
  Result ParseBufferInitializerFile(Buffer*);
  Result ParseShaderBlock();
  Result ParsePipelineBlock();
  Result ParsePipelineAttach(Pipeline*);
  Result ParsePipelineShaderOptimizations(Pipeline*);
  Result ParsePipelineShaderCompileOptions(Pipeline*);
  Result ParsePipelineSubgroup(Pipeline* pipeline);
  Result ParsePipelinePatchControlPoints(Pipeline* pipeline);
  Result ParsePipelineFramebufferSize(Pipeline*);
  Result ParsePipelineViewport(Pipeline*);
  Result ParsePipelineBind(Pipeline*);
  Result ParsePipelineVertexData(Pipeline*);
  Result ParsePipelineIndexData(Pipeline*);
  Result ParsePipelineSet(Pipeline*);
  Result ParsePipelinePolygonMode(Pipeline*);
  Result ParsePipelineDepth(Pipeline* pipeline);
  Result ParsePipelineStencil(Pipeline* pipeline);
  Result ParsePipelineBlend(Pipeline* pipeline);
  Result ParseRun();
  Result ParseClear();
  Result ParseClearColor();
  Result ParseClearDepth();
  Result ParseClearStencil();
  Result ParseExpect();
  Result ParseCopy();
  Result ParseDeviceFeature();
  Result ParseDeviceExtension();
  Result ParseInstanceExtension();
  Result ParseRepeat();
  Result ParseSet();
  bool IsRepeatable(const std::string& name) const;
  Result ParseRepeatableCommand(const std::string& name);
  Result ParseDerivePipelineBlock();
  Result ParsePipelineBody(const std::string& cmd_name,
                           std::unique_ptr<Pipeline> pipeline);
  Result ParseShaderSpecialization(Pipeline* pipeline);
  Result ParseSampler();
  Result ParseTolerances(std::vector<Probe::Tolerance>* tolerances);

  /// Parses a set of values out of the token stream. |name| is the name of the
  /// current command we're parsing for error purposes. The |type| is the type
  /// of data we expect for the current buffer. |values| will be appended to
  /// with the parsed values.
  Result ParseValues(const std::string& name,
                     Format* fmt,
                     std::vector<Value>* values);

  Result ParseVirtualFile();

  std::unique_ptr<Tokenizer> tokenizer_;
  std::vector<std::unique_ptr<Command>> command_list_;
};

}  // namespace amberscript
}  // namespace amber

#endif  // SRC_AMBERSCRIPT_PARSER_H_