/* stores the table of offsets for all records of the current file for
   faster access.  */
static void LoadOffsets(axxPacFD fd)
{
    MemPtr mp;

    /* assumption: there is just one file being read */
    ASSERT_MSG("AIM6", currFileDesc == -1);

    axxPacSeek(LibRef, fd, 76, SEEK_SET);
    axxPacRead(LibRef, fd, &nrec, 2);
    moff = MemHandleNew(nrec * 8L);
    ASSERT_MSG("AIM3", moff != 0);

    mp = MemHandleLock(moff);
    ASSERT_MSG("AIM4", mp != 0);

    axxPacSeek(LibRef, fd, 78, SEEK_SET);
    axxPacRead(LibRef, fd, mp, nrec * 8L);
    MemHandleUnlock(moff);
    currFileDesc = fd;
    nrec--;
}

void VertexLoader::Setup(const PipelineRegs& regs) {
    ASSERT_MSG(!is_setup, "VertexLoader is not intended to be setup more than once.");

    const auto& attribute_config = regs.vertex_attributes;
    num_total_attributes = attribute_config.GetNumTotalAttributes();

    boost::fill(vertex_attribute_sources, 0xdeadbeef);

    for (int i = 0; i < 16; i++) {
        vertex_attribute_is_default[i] = attribute_config.IsDefaultAttribute(i);
    }

    // Setup attribute data from loaders
    for (int loader = 0; loader < 12; ++loader) {
        const auto& loader_config = attribute_config.attribute_loaders[loader];

        u32 offset = 0;

        // TODO: What happens if a loader overwrites a previous one's data?
        for (unsigned component = 0; component < loader_config.component_count; ++component) {
            if (component >= 12) {
                LOG_ERROR(HW_GPU,
                          "Overflow in the vertex attribute loader %u trying to load component %u",
                          loader, component);
                continue;
            }

            u32 attribute_index = loader_config.GetComponent(component);
            if (attribute_index < 12) {
                offset = Common::AlignUp(offset,
                                         attribute_config.GetElementSizeInBytes(attribute_index));
                vertex_attribute_sources[attribute_index] = loader_config.data_offset + offset;
                vertex_attribute_strides[attribute_index] =
                    static_cast<u32>(loader_config.byte_count);
                vertex_attribute_formats[attribute_index] =
                    attribute_config.GetFormat(attribute_index);
                vertex_attribute_elements[attribute_index] =
                    attribute_config.GetNumElements(attribute_index);
                offset += attribute_config.GetStride(attribute_index);
            } else if (attribute_index < 16) {
                // Attribute ids 12, 13, 14 and 15 signify 4, 8, 12 and 16-byte paddings,
                // respectively
                offset = Common::AlignUp(offset, 4);
                offset += (attribute_index - 11) * 4;
            } else {
                UNREACHABLE(); // This is truly unreachable due to the number of bits for each
                               // component
            }
        }
    }

    is_setup = true;
}

void DX9VertexShader::setVec4( const char* paramName, const D3DXVECTOR4& vec )
{
   if ( m_activeConstantsTable )
   {
      D3DXHANDLE hConstant = m_activeConstantsTable->GetConstantByName( NULL, paramName );
      if ( hConstant )
      {
         HRESULT res = m_activeConstantsTable->SetVector( m_d3Device, hConstant, &vec );
         ASSERT_MSG( SUCCEEDED( res ), translateDxError( "setVec4", res ).c_str() );
      }
   }
}

const Quadtree<T,D>* Quadtree<T,D>::FindLeafNode(const vec<T,D>* p) const
{
	if(IsLeaf())
    {
        ASSERT(ContainsPoint(p));
        return this;
    }
    
    Orthant<D> orthant = GetOrthant(p);
    ASSERT_MSG(children[orthant] != NULL, "The point does not appear in a leaf node in the quadtree.\n");
    return children[orthant]->FindLeafNode(p);    
}

void mtx_init( Tmtx_ptr A, int nrows, int ncols )
{
	if( A->init )
		mtx_free( A );
	
	A->init = 1;
	A->nrows = nrows;
	A->ncols = ncols;
	A->dat = (double *)calloc( nrows*ncols, sizeof(double) );
	A->tau = NULL;		// This is only allocated by least squares routines
	ASSERT_MSG( A->dat!=NULL, "mtx_init() : unable calloc memory for dense matrix" );
}

Orthant<D> Quadtree<T,D>::GetOrthant(const vec<T,D>* p) const
{
    ASSERT_MSG(ContainsPoint(p), "The node does not contain the point for which we try to find the orthant.\n");

    Orthant<D> orthant;
    for(int d=0; d<D; ++d)
    {
        orthant.Set(d, minPoint[d] + (sideLength/T(2)) < (*p)[d]);
    }

    return orthant;
}

/**
 * DSP_DSP::WriteProcessPipe service function
 *  Inputs:
 *      1 : Pipe Number
 *      2 : Size
 *      3 : (size << 14) | 0x402
 *      4 : Buffer
 *  Outputs:
 *      0 : Return header
 *      1 : Result of function, 0 on success, otherwise error code
 */
static void WriteProcessPipe(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();

    u32 pipe_index = cmd_buff[1];
    u32 size = cmd_buff[2];
    u32 buffer = cmd_buff[4];

    AudioCore::DspPipe pipe = static_cast<AudioCore::DspPipe>(pipe_index);

    if (IPC::StaticBufferDesc(size, 1) != cmd_buff[3]) {
        LOG_ERROR(Service_DSP,
                  "IPC static buffer descriptor failed validation (0x%X). pipe=%u, "
                  "size=0x%X, buffer=0x%08X",
                  cmd_buff[3], pipe_index, size, buffer);
        cmd_buff[0] = IPC::MakeHeader(0, 1, 0);
        cmd_buff[1] = IPC::ERR_INVALID_BUFFER_DESCRIPTOR.raw;
        return;
    }

    ASSERT_MSG(Memory::IsValidVirtualAddress(buffer),
               "Invalid Buffer: pipe={}, size={:#X}, buffer={:#010X}", pipe_index, size, buffer);

    std::vector<u8> message(size);
    for (u32 i = 0; i < size; i++) {
        message[i] = Memory::Read8(buffer + i);
    }

    // This behaviour was confirmed by RE.
    // The likely reason for this is that games tend to pass in garbage at these bytes
    // because they read random bytes off the stack.
    switch (pipe) {
    case AudioCore::DspPipe::Audio:
        ASSERT(message.size() >= 4);
        message[2] = 0;
        message[3] = 0;
        break;
    case AudioCore::DspPipe::Binary:
        ASSERT(message.size() >= 8);
        message[4] = 1;
        message[5] = 0;
        message[6] = 0;
        message[7] = 0;
        break;
    }

    Core::DSP().PipeWrite(pipe, message);

    cmd_buff[0] = IPC::MakeHeader(0xD, 1, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw; // No error

    LOG_DEBUG(Service_DSP, "pipe=%u, size=0x%X, buffer=0x%08X", pipe_index, size, buffer);
}

EventType* RegisterEvent(const std::string& name, TimedCallback callback) {
    // check for existing type with same name.
    // we want event type names to remain unique so that we can use them for serialization.
    ASSERT_MSG(event_types.find(name) == event_types.end(),
               "CoreTiming Event \"{}\" is already registered. Events should only be registered "
               "during Init to avoid breaking save states.",
               name);

    auto info = event_types.emplace(name, EventType{callback, nullptr});
    EventType* event_type = &info.first->second;
    event_type->name = &info.first->first;
    return event_type;
}

static void command_postfork(void *data) {
	struct lua_command_data *lcd = data;
	struct lua_State *L = lcd->L;
	ASSERT(L);
	// This would be called from within the lua_run_command, no need to allocate more stack
	if (lcd->postfork_callback) {
		int handler = push_err_handler(L);
		extract_registry_value(L, lcd->postfork_callback);
		int result = lua_pcall(L, 0, 0, handler);
		ASSERT_MSG(!result, "%s", interpreter_error_result(L));
	}
	// We don't worry about freeing memory here. We're going to exec just in a while.
}

int CR_thread_start( unsigned int n )
{
    nspawns = n;

    if ( m_state_get() == M_RESTART ) {
        ASSERT_MSG( restart_version >= 0, "Internal error" );
    }

#ifndef CR_FTB
    // This must be called before mpispawn are started
    // Do not move this to CR_Loop()
    if (USE_LINEAR_SSH) {
        if (!show_on) {
            int rv = create_connections();
            if ( rv != 0 ) {
                return -1;
            }
        }
    }
#endif

    struct timeval starting;
    gettimeofday(&starting, NULL);
    starting_time = last_ckpt = starting.tv_sec;

    // Check and set CR state
    CR_state_lock();
    ASSERT_MSG( cr_state == CR_INIT || cr_state == CR_STOPPED, "Internal Error\n");
    CR_state_transition_nolock( CR_INIT );
    CR_state_unlock();

    if (pthread_create(&cr_tid, NULL, CR_Loop, NULL) < 0) {
        PRINT_ERROR_ERRNO("pthread_create() failed", errno);
        cr_tid = 0;
        return -1;
    }

    return 0;
}

/**
 * DSP_DSP::RecvDataIsReady service function
 *      This function checks whether a DSP register is ready to be read.
 *  Inputs:
 *      1 : Register Number
 *  Outputs:
 *      1 : Result of function, 0 on success, otherwise error code
 *      2 : non-zero == ready
 *  Note:
 *      This function has only been observed being called with a register number of 0.
 */
static void RecvDataIsReady(Service::Interface* self) {
    u32* cmd_buff = Kernel::GetCommandBuffer();

    u32 register_number = cmd_buff[1];

    ASSERT_MSG(register_number == 0, "Unknown register_number {}", register_number);

    cmd_buff[0] = IPC::MakeHeader(0x2, 2, 0);
    cmd_buff[1] = RESULT_SUCCESS.raw;
    cmd_buff[2] = 1; // Ready to read

    LOG_DEBUG(Service_DSP, "register_number=%u", register_number);
}

void *kmalloc_pages(size_t npages)
{
    void *p;

    p = kmalloc(npages * PAGE_SIZE);
    if (!p)
        return NULL;

    /* check page alignment in debug kernels */
    ASSERT_MSG(!((addr_t)p % PAGE_SIZE), "allocated memory is not page aligned!\n");

    return p;
}

void Sound3D::assignChannel(SoundDevice& device)
{
   if (m_channel != NULL)
   {
      ASSERT_MSG( false, "The 3d sound already has a channel assigned");
      return;
   }

   m_channel = &(device.activateSound(m_sound));
   onChannelAssigned(*m_channel);
   m_channel->setLooped(m_looped);
   m_channel->play();
}

 /**
  * Returns the type of the SArray (as set by 
  * \ref swriter<flexible_type>::set_type). If the type of the SArray was
  * not set, this returns \ref flex_type_enum::UNDEFINED, in which case
  * each row can be of arbitrary type.
  *
  * This function should only be used for sarray<flexible_type> and
  * will fail fatally otherwise.
  */
 flex_type_enum get_type() const {
   if (!std::is_same<T, flexible_type>::value) {
     ASSERT_MSG(false, 
                 "Use of get_type() in SArray which "
                 "does not contain flexible_types");
   }
   ASSERT_NE(reader, NULL);
   const index_file_information& index_info = reader->get_index_info();
   if (index_info.metadata.count("__type__")) {
     return flex_type_enum::UNDEFINED;
   }
   return flex_type_enum(std::stoi(index_info.metadata.at("__type__")));
 }

/* create user process */
process_t *proc_create_user_process(const char *name, process_t *parent,
    vm_address_space_t *aspace, const char *args, uint role)
{
    process_t *proc;

    ASSERT_MSG(name != NULL && strlen(name) <= SYS_MAX_OS_NAME_LEN,
        "proc_create_user_process: user process name is invalid!\n");

    /* check args */
    if(aspace == NULL || role > PROCESS_ROLES_COUNT)
        return NULL;

    /* create process struct */
    proc = create_process_common(name, args);
    if(!proc)
        return INVALID_PROCESSID;

    /* init struct fields */
    proc->aspace = vm_inc_aspace_refcnt(aspace);
    if(!proc->aspace)
        goto error_exit;
    if(parent) {
        proc->parent = proc_inc_refcnt(parent);
        if(!proc->parent)
            goto error_exit;
    }
    proc->aid = proc->aspace->id;
    proc->process_role = role;
    proc->def_prio = process_roles_props[proc->process_role].def_prio;
    proc->def_sched_policy.raw =
        process_roles_props[proc->process_role].def_sched_policy.raw;
    atomic_set((atomic_t*)&proc->ref_count, 1); /* already has one ref owned by caller */

    /* init arch-dependend part */
    if(arch_init_process_struct(proc) != NO_ERROR)
        goto error_exit;

    /* add to processes list */
    put_process_to_list(proc);

    return proc; /* return to caller */

/* exit on errors */
error_exit:
    if(proc->aspace) vm_put_aspace(proc->aspace);
    if(proc->parent) proc_put_process(proc->parent);

    destroy_process_common(proc);

    return NULL;
}

void MainEditorPanel::saveLayout( QSettings& outSettings )
{
   char tmpEditorGroupStr[32];

   outSettings.beginGroup( "MainEditorPanel/activeEditors" );

   // first - serialize the active project's path, if there's one
   Project* activeProject = TamyEditor::getInstance().getActiveProject();
   if ( activeProject )
   {
      FilePath projectPath = activeProject->getFilePath();
      outSettings.setValue( "activeProjectPath", QString( projectPath.c_str() ) );
   }
   
   // if there's an active project, serialize the active editors ( editors may work only in the project scope )
   if ( activeProject )
   {
      std::vector< ResourceEditor* > editors;
      std::vector< TabLocation > tabsLocations;
      collectEditors( editors, &tabsLocations );

      uint count = editors.size();
      outSettings.setValue( "editorsCount", count );
      for ( uint i = 0; i < count; ++i )
      {
         ResourceEditor* editor = editors[i];

         // create a new group for each editor
         sprintf( tmpEditorGroupStr, "editor_%d", i );
         outSettings.beginGroup( tmpEditorGroupStr );
         {
            // save the layout data
            outSettings.setValue( "internal", tabsLocations[i].m_internal );
            if ( tabsLocations[i].m_internal == false )
            {
               QWidget* parentWidget = editor->parentWidget();
               ASSERT_MSG( dynamic_cast< QDockWidget* >( parentWidget ), "A detached ResourceEditor is expected to be embedded in a QDockWidget" );

               QDockWidget* parentDockWidget = static_cast< QDockWidget* >( parentWidget );
               Qt::DockWidgetArea dockArea = m_mainWindow->dockWidgetArea( parentDockWidget );
               outSettings.setValue( "dockArea", (int)dockArea );
            }

            outSettings.setValue( "path", editor->getLabel() );
            outSettings.setValue( "icon", editor->getIcon().name() );
         }
         outSettings.endGroup();
      }
   }
   outSettings.endGroup();
}

void SceneGraph::AddNode(ISceneNode* pNode)
{
	ASSERT(pNode);
	ASSERT_MSG(!pNode->mRemoveNodePostUpdate, "Probably got scheduled for remove then added in same frame");

	//@LAME: Because we multiply inherit ISceneNode and IPhysical, we need to do this here
	if (IPhysical* pPhysical = DynamicCast<IPhysical*>(pNode))
	{
		mPhysicalList.push_back(pPhysical);
	}

	mSceneNodeList.push_back(pNode);
	pNode->OnAddToScene();
}

/**
 * @return The user’s home directory on POSIX systems
 */
static const std::string& GetHomeDirectory() {
    static std::string home_path;
    if (home_path.empty()) {
        const char* envvar = getenv("HOME");
        if (envvar) {
            home_path = envvar;
        } else {
            auto pw = getpwuid(getuid());
            ASSERT_MSG(pw, "$HOME isn’t defined, and the current user can’t be found in /etc/passwd.");
            home_path = pw->pw_dir;
        }
    }
    return home_path;
}

/////////////////////////////////////
// Name:	MDLSetMaterial
// Purpose:	sets/change model's
//			texture within material
//			index
// Output:	model's texture change
// Return:	RETCODE_SUCCESS if success
/////////////////////////////////////
PUBLIC RETCODE MDLSetMaterial(hMDL model, int materialInd, const GFXMATERIAL &material)
{
	//allocate materials if there is none
	//set it automatically to one
	if(model->numMaterial == 0)
	{
		model->numMaterial = 1;
		model->materials = (GFXMATERIAL*)GFX_MALLOC(sizeof(GFXMATERIAL)*model->numMaterial);
		if(!model->materials)
		{ ASSERT_MSG(0, "Unable to allocate model materials", "Error in MDLSetMaterial"); return RETCODE_FAILURE; }

		memcpy(&model->materials[0], &material, sizeof(GFXMATERIAL));
	}
	else
	{
		if(materialInd >= model->numMaterial)
		{ ASSERT_MSG(0, "Bad material index", "Error in MDLSetMaterial"); return RETCODE_FAILURE; }

		memcpy(&model->materials[materialInd], &material, sizeof(GFXMATERIAL));
	}

	return RETCODE_SUCCESS;
}

    template <typename F> void GpuFFTPlanCl<F>::doExecute (const cl::CommandQueue& queue, const cl::Buffer& input, csize_t inputOffset, const cl::Buffer& output, csize_t outputOffset, bool doForward) const {
      if (supportNonZeroOffsets) {
        if (inputOffset != 0 || outputOffset != 0) {
          queue.enqueueCopyBuffer (input, tmp.getDataWritable (), (inputOffset * sizeof (std::complex<F>)) (), 0, (csize_t (sizeof (std::complex<F>)) * this->batchSize ()).value ());
          doExecute (queue, tmp.getDataWritable (), 0, tmp.getDataWritable (), 0, doForward);
          queue.enqueueCopyBuffer (tmp.getData (), output, 0, (outputOffset * sizeof (std::complex<F>)) (), (csize_t (sizeof (std::complex<F>)) * this->batchSize ()).value ());
          return;
        }
      } else {
        ASSERT_MSG (inputOffset == 0, "not implemented");
        ASSERT_MSG (outputOffset == 0, "not implemented");
      }

      if (this->size () == 0)
        return;
      if (this->size () == 1) {
        if (input () != output ())
          queue.enqueueCopyBuffer (input, output, 0, 0, (csize_t (sizeof (std::complex<F>)) * this->batchCount ()).value ());
        return;
      }

      cl::detail::errHandler (VAL(ExecuteInterleaved) (queue (), static_cast<TY(Plan)> (plan), Core::checked_cast<int> (this->batchCount ()), doForward ? VAL(Forward) : VAL(Inverse), input (), output (), 0, NULL, NULL), VAL(ExecuteInterleavedStr));
    }