/**
 ******************************************************************************
 * Xenia : Xbox 360 Emulator Research Project                                 *
 ******************************************************************************
 * Copyright 2019 Ben Vanik. All rights reserved.                             *
 * Released under the BSD license - see LICENSE in the root for more details. *
 ******************************************************************************
 */

#include "xenia/gpu/d3d12/deferred_command_list.h"

#include "xenia/base/assert.h"
#include "xenia/base/math.h"
#include "xenia/gpu/d3d12/d3d12_command_processor.h"

namespace xe {
namespace gpu {
namespace d3d12 {

constexpr size_t DeferredCommandList::kAlignment;

DeferredCommandList::DeferredCommandList(
    D3D12CommandProcessor* command_processor, size_t initial_size)
    : command_processor_(command_processor) {
  command_stream_.reserve(initial_size);
}

void DeferredCommandList::Reset() { command_stream_.clear(); }

void DeferredCommandList::Execute(ID3D12GraphicsCommandList* command_list,
                                  ID3D12GraphicsCommandList1* command_list_1) {
  const uint8_t* stream = command_stream_.data();
  size_t stream_remaining = command_stream_.size();
  ID3D12PipelineState* current_pipeline_state = nullptr;
  while (stream_remaining != 0) {
    const uint32_t* header = reinterpret_cast<const uint32_t*>(stream);
    const size_t header_size = xe::align(2 * sizeof(uint32_t), kAlignment);
    stream += header_size;
    stream_remaining -= header_size;
    switch (Command(header[0])) {
      case Command::kD3DClearUnorderedAccessViewUint: {
        auto& args =
            *reinterpret_cast<const ClearUnorderedAccessViewHeader*>(stream);
        command_list->ClearUnorderedAccessViewUint(
            args.view_gpu_handle_in_current_heap, args.view_cpu_handle,
            args.resource, args.values_uint, args.num_rects,
            args.num_rects ? reinterpret_cast<const D3D12_RECT*>(&args + 1)
                           : nullptr);
      } break;
      case Command::kD3DCopyBufferRegion: {
        auto& args =
            *reinterpret_cast<const D3DCopyBufferRegionArguments*>(stream);
        command_list->CopyBufferRegion(args.dst_buffer, args.dst_offset,
                                       args.src_buffer, args.src_offset,
                                       args.num_bytes);
      } break;
      case Command::kD3DCopyResource: {
        auto& args = *reinterpret_cast<const D3DCopyResourceArguments*>(stream);
        command_list->CopyResource(args.dst_resource, args.src_resource);
      } break;
      case Command::kCopyTexture: {
        auto& args = *reinterpret_cast<const CopyTextureArguments*>(stream);
        command_list->CopyTextureRegion(&args.dst, 0, 0, 0, &args.src, nullptr);
      } break;
      case Command::kD3DDispatch: {
        if (current_pipeline_state != nullptr) {
          auto& args = *reinterpret_cast<const D3DDispatchArguments*>(stream);
          command_list->Dispatch(args.thread_group_count_x,
                                 args.thread_group_count_y,
                                 args.thread_group_count_z);
        }
      } break;
      case Command::kD3DDrawIndexedInstanced: {
        if (current_pipeline_state != nullptr) {
          auto& args =
              *reinterpret_cast<const D3DDrawIndexedInstancedArguments*>(
                  stream);
          command_list->DrawIndexedInstanced(
              args.index_count_per_instance, args.instance_count,
              args.start_index_location, args.base_vertex_location,
              args.start_instance_location);
        }
      } break;
      case Command::kD3DDrawInstanced: {
        if (current_pipeline_state != nullptr) {
          auto& args =
              *reinterpret_cast<const D3DDrawInstancedArguments*>(stream);
          command_list->DrawInstanced(
              args.vertex_count_per_instance, args.instance_count,
              args.start_vertex_location, args.start_instance_location);
        }
      } break;
      case Command::kD3DIASetIndexBuffer: {
        auto view = reinterpret_cast<const D3D12_INDEX_BUFFER_VIEW*>(stream);
        command_list->IASetIndexBuffer(
            view->Format != DXGI_FORMAT_UNKNOWN ? view : nullptr);
      } break;
      case Command::kD3DIASetPrimitiveTopology: {
        command_list->IASetPrimitiveTopology(
            *reinterpret_cast<const D3D12_PRIMITIVE_TOPOLOGY*>(stream));
      } break;
      case Command::kD3DOMSetBlendFactor: {
        command_list->OMSetBlendFactor(reinterpret_cast<const FLOAT*>(stream));
      } break;
      case Command::kD3DOMSetRenderTargets: {
        auto& args =
            *reinterpret_cast<const D3DOMSetRenderTargetsArguments*>(stream);
        command_list->OMSetRenderTargets(
            args.num_render_target_descriptors, args.render_target_descriptors,
            args.rts_single_handle_to_descriptor_range ? TRUE : FALSE,
            args.depth_stencil ? &args.depth_stencil_descriptor : nullptr);
      } break;
      case Command::kD3DOMSetStencilRef: {
        command_list->OMSetStencilRef(*reinterpret_cast<const UINT*>(stream));
      } break;
      case Command::kD3DResourceBarrier: {
        command_list->ResourceBarrier(
            *reinterpret_cast<const UINT*>(stream),
            reinterpret_cast<const D3D12_RESOURCE_BARRIER*>(
                stream +
                xe::align(sizeof(UINT), alignof(D3D12_RESOURCE_BARRIER))));
      } break;
      case Command::kRSSetScissorRect: {
        command_list->RSSetScissorRects(
            1, reinterpret_cast<const D3D12_RECT*>(stream));
      } break;
      case Command::kRSSetViewport: {
        command_list->RSSetViewports(
            1, reinterpret_cast<const D3D12_VIEWPORT*>(stream));
      } break;
      case Command::kD3DSetComputeRoot32BitConstants: {
        auto args =
            reinterpret_cast<const SetRoot32BitConstantsHeader*>(stream);
        command_list->SetComputeRoot32BitConstants(
            args->root_parameter_index, args->num_32bit_values_to_set, args + 1,
            args->dest_offset_in_32bit_values);
      } break;
      case Command::kD3DSetGraphicsRoot32BitConstants: {
        auto args =
            reinterpret_cast<const SetRoot32BitConstantsHeader*>(stream);
        command_list->SetGraphicsRoot32BitConstants(
            args->root_parameter_index, args->num_32bit_values_to_set, args + 1,
            args->dest_offset_in_32bit_values);
      } break;
      case Command::kD3DSetComputeRootConstantBufferView: {
        auto& args =
            *reinterpret_cast<const SetRootConstantBufferViewArguments*>(
                stream);
        command_list->SetComputeRootConstantBufferView(
            args.root_parameter_index, args.buffer_location);
      } break;
      case Command::kD3DSetGraphicsRootConstantBufferView: {
        auto& args =
            *reinterpret_cast<const SetRootConstantBufferViewArguments*>(
                stream);
        command_list->SetGraphicsRootConstantBufferView(
            args.root_parameter_index, args.buffer_location);
      } break;
      case Command::kD3DSetComputeRootDescriptorTable: {
        auto& args =
            *reinterpret_cast<const SetRootDescriptorTableArguments*>(stream);
        command_list->SetComputeRootDescriptorTable(args.root_parameter_index,
                                                    args.base_descriptor);
      } break;
      case Command::kD3DSetGraphicsRootDescriptorTable: {
        auto& args =
            *reinterpret_cast<const SetRootDescriptorTableArguments*>(stream);
        command_list->SetGraphicsRootDescriptorTable(args.root_parameter_index,
                                                     args.base_descriptor);
      } break;
      case Command::kD3DSetComputeRootSignature: {
        command_list->SetComputeRootSignature(
            *reinterpret_cast<ID3D12RootSignature* const*>(stream));
      } break;
      case Command::kD3DSetGraphicsRootSignature: {
        command_list->SetGraphicsRootSignature(
            *reinterpret_cast<ID3D12RootSignature* const*>(stream));
      } break;
      case Command::kSetDescriptorHeaps: {
        auto& args =
            *reinterpret_cast<const SetDescriptorHeapsArguments*>(stream);
        UINT num_descriptor_heaps = 0;
        ID3D12DescriptorHeap* descriptor_heaps[2];
        if (args.cbv_srv_uav_descriptor_heap != nullptr) {
          descriptor_heaps[num_descriptor_heaps++] =
              args.cbv_srv_uav_descriptor_heap;
        }
        if (args.sampler_descriptor_heap != nullptr) {
          descriptor_heaps[num_descriptor_heaps++] =
              args.sampler_descriptor_heap;
        }
        command_list->SetDescriptorHeaps(num_descriptor_heaps,
                                         descriptor_heaps);
      } break;
      case Command::kD3DSetPipelineState: {
        current_pipeline_state =
            *reinterpret_cast<ID3D12PipelineState* const*>(stream);
        if (current_pipeline_state) {
          command_list->SetPipelineState(current_pipeline_state);
        }
      } break;
      case Command::kSetPipelineStateHandle: {
        current_pipeline_state =
            command_processor_->GetD3D12PipelineStateByHandle(
                *reinterpret_cast<void* const*>(stream));
        if (current_pipeline_state) {
          command_list->SetPipelineState(current_pipeline_state);
        }
      } break;
      case Command::kD3DSetSamplePositions: {
        if (command_list_1 != nullptr) {
          auto& args =
              *reinterpret_cast<const D3DSetSamplePositionsArguments*>(stream);
          command_list_1->SetSamplePositions(
              args.num_samples_per_pixel, args.num_pixels,
              const_cast<D3D12_SAMPLE_POSITION*>(args.sample_positions));
        }
      } break;
      default:
        assert_unhandled_case(Command(header[0]));
        break;
    }
    stream += header[1];
    stream_remaining -= header[1];
  }
}

void* DeferredCommandList::WriteCommand(Command command,
                                        size_t arguments_size) {
  arguments_size = xe::align(arguments_size, kAlignment);
  const size_t header_size = xe::align(2 * sizeof(uint32_t), kAlignment);
  size_t offset = command_stream_.size();
  command_stream_.resize(offset + header_size + arguments_size);
  uint32_t* header =
      reinterpret_cast<uint32_t*>(command_stream_.data() + offset);
  header[0] = uint32_t(command);
  header[1] = uint32_t(arguments_size);
  return command_stream_.data() + (offset + header_size);
}

}  // namespace d3d12
}  // namespace gpu
}  // namespace xe