/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef MAIN_MODEL_LOADER_H
#define MAIN_MODEL_LOADER_H


#include <util/DoublyLinkedList.h>

#include "AbstractModelLoader.h"
#include "Model.h"


class BDataIO;
class BDebugEventInputStream;
class DataSource;
struct system_profiler_thread_added;


class ModelLoader : public AbstractModelLoader {
public:
                                                                ModelLoader(DataSource* dataSource,
                                                                        const BMessenger& target,
                                                                        void* targetCookie);

protected:
                                                                ~ModelLoader();

public:
                        Model*                          DetachModel();

protected:
        virtual status_t                        PrepareForLoading();
        virtual status_t                        Load();
        virtual void                            FinishLoading(bool success);

private:
                        // shorthands for the longish structure names
                        typedef system_profiler_thread_enqueued_in_run_queue
                                thread_enqueued_in_run_queue;
                        typedef system_profiler_thread_removed_from_run_queue
                                thread_removed_from_run_queue;
                        typedef system_profiler_io_request_scheduled io_request_scheduled;
                        typedef system_profiler_io_request_finished io_request_finished;
                        typedef system_profiler_io_operation_started io_operation_started;
                        typedef system_profiler_io_operation_finished io_operation_finished;

                        struct CPUInfo;
                        struct IOOperation;
                        struct IORequest;
                        struct IORequestHashDefinition;
                        struct ExtendedThreadSchedulingState;
                        struct ExtendedSchedulingState;

                        typedef DoublyLinkedList<ModelLoader::IOOperation> IOOperationList;
                        typedef DoublyLinkedList<ModelLoader::IORequest> IORequestList;
                        typedef BOpenHashTable<IORequestHashDefinition> IORequestTable;

private:
                        status_t                        _Load();
                        status_t                        _ReadDebugEvents(void** _eventData,
                                                                        size_t* _size);
                        status_t                        _CreateDebugEventArray(void* eventData,
                                                                        size_t eventDataSize,
                                                                        system_profiler_event_header**& _events,
                                                                        size_t& _eventCount);
                        status_t                        _ProcessEvent(uint32 event, uint32 cpu,
                                                                        const void* buffer, size_t size);
                        bool                            _SetThreadEvents();
                        bool                            _SetThreadIORequests();
                        void                            _SetThreadIORequests(Model::Thread* thread,
                                                                        Model::IORequest** requests,
                                                                        size_t requestCount);

        inline  void                            _UpdateLastEventTime(nanotime_t time);

                        void                            _HandleTeamAdded(
                                                                        system_profiler_team_added* event);
                        void                            _HandleTeamRemoved(
                                                                        system_profiler_team_removed* event);
                        void                            _HandleTeamExec(
                                                                        system_profiler_team_exec* event);
                        void                            _HandleThreadAdded(
                                                                        system_profiler_thread_added* event);
                        void                            _HandleThreadRemoved(
                                                                        system_profiler_thread_removed* event);
                        void                            _HandleThreadScheduled(uint32 cpu,
                                                                        system_profiler_thread_scheduled* event);
                        void                            _HandleThreadEnqueuedInRunQueue(
                                                                        thread_enqueued_in_run_queue* event);
                        void                            _HandleThreadRemovedFromRunQueue(uint32 cpu,
                                                                        thread_removed_from_run_queue* event);
                        void                            _HandleWaitObjectInfo(
                                                                        system_profiler_wait_object_info* event);
                        void                            _HandleIOSchedulerAdded(
                                                                        system_profiler_io_scheduler_added* event);
                        void                            _HandleIORequestScheduled(
                                                                        io_request_scheduled* event);
                        void                            _HandleIORequestFinished(
                                                                        io_request_finished* event);
                        void                            _HandleIOOperationStarted(
                                                                        io_operation_started* event);
                        void                            _HandleIOOperationFinished(
                                                                        io_operation_finished* event);

                        ExtendedThreadSchedulingState* _AddThread(
                                                                        system_profiler_thread_added* event);
                        ExtendedThreadSchedulingState* _AddUnknownThread(
                                                                        thread_id threadID);
                        Model::Team*            _AddUnknownTeam();
                        
                        void                            _AddThreadWaitObject(
                                                                        ExtendedThreadSchedulingState* thread,
                                                                        uint32 type, addr_t object);

                        void                            _AddIdleTime(uint32 cpu, nanotime_t time);

private:
                        Model*                          fModel;
                        DataSource*                     fDataSource;
                        CPUInfo*                        fCPUInfos;
                        nanotime_t                      fBaseTime;
                        ExtendedSchedulingState* fState;
                        IORequestTable*         fIORequests;
                        uint32                          fMaxCPUIndex;
};


#endif  // MAIN_MODEL_LOADER_H