//
// Copyright 2005 The Android Open Source Project
//
// Simulated device definition.
//
// The "root" of the data structures here is PhoneCollection, which may
// discard the entire set if the user asks to re-scan the phone definitions.
// These structures should be considered read-only.
//
// PhoneCollection (single global instance)
//    -->PhoneData
//       -->PhoneDisplay
//       -->PhoneMode
//          -->PhoneView
//
#ifndef _SIM_PHONE_DATA_H
#define _SIM_PHONE_DATA_H

#include <stdio.h>
#include "tinyxml.h"

#include "PhoneButton.h"
#include "LoadableImage.h"
#include <ui/PixelFormat.h>
#include "utils.h"


/*
 * This represents the keyboard type of the simulated device
 */
class PhoneKeyboard {
public:
    PhoneKeyboard(void)
        : mQwerty(false), mKeyMap(NULL)
        {}       
    ~PhoneKeyboard(void) {
        free((void*)mKeyMap);
    }    
 
    PhoneKeyboard(const PhoneKeyboard& src)
        : mQwerty(false), mKeyMap(NULL)
    {
        CopyMembers(src);
    }
    PhoneKeyboard& operator=(const PhoneKeyboard& src) {
        if (this != &src)       // self-assignment
            CopyMembers(src);
        return *this;
    }
    void CopyMembers(const PhoneKeyboard& src) {
        mQwerty = src.mQwerty;
        mKeyMap = src.mKeyMap ? strdup(src.mKeyMap) : NULL;
    }
    
    bool ProcessAndValidate(TiXmlNode* pNode);
    
    bool getQwerty() { return mQwerty; }    

    const char *getKeyMap() { return mKeyMap; }
private:
    bool    mQwerty;
    const char * mKeyMap;
};

/*
 * This represents a single display device, usually an LCD screen.
 * It also includes an optional surrounding graphic, usually a picture of
 * the device itself.
 */
class PhoneDisplay {
public:
    PhoneDisplay(void)
        : mName(NULL)
        {}
    ~PhoneDisplay(void) {
        delete[] mName;
    }

    PhoneDisplay(const PhoneDisplay& src)
        : mName(NULL)
    {
        CopyMembers(src);
    }
    PhoneDisplay& operator=(const PhoneDisplay& src) {
        if (this != &src)       // self-assignment
            CopyMembers(src);
        return *this;
    }
    void CopyMembers(const PhoneDisplay& src) {
        // Can't memcpy and member-copy the container classes, because the
        // containers have already been constructed, and for operator= they
        // might even have stuff in them.
        delete[] mName;
        mName = android::strdupNew(src.mName);
        mWidth = src.mWidth;
        mHeight = src.mHeight;
        mFormat = src.mFormat;
        mRefresh = src.mRefresh;
    }

    bool ProcessAndValidate(TiXmlNode* pNode);

    const char* GetName(void) const { return mName; }
    int GetWidth(void) const { return mWidth; }
    int GetHeight(void) const { return mHeight; }
    android::PixelFormat GetFormat(void) const { return mFormat; }
    int GetRefresh(void) const { return mRefresh; }

    static bool IsCompatible(PhoneDisplay* pDisplay1, PhoneDisplay* pDisplay2);

private:
    char*           mName;

    // display dimensions, in pixels
    int             mWidth;
    int             mHeight;

    // frame buffer format
    android::PixelFormat mFormat;

    // display refresh rate, in fps
    int             mRefresh;
};

/*
 * This is a "view" of a device, which includes the display, a background
 * image, and perhaps some clickable keys for input.
 *
 * Because the key graphics are associated with a particular display, we
 * hold a list of keys here.  (It also allows the possibility of handling
 * a situation where the same key shows up in multiple background images,
 * e.g. a flip phone with a "volume" key on the side.  If we include the
 * key in both places, we can highlight it on both displays.)
 */
class PhoneView {
public:
    PhoneView(void)
        : mDisplayName(NULL)
        {}
    ~PhoneView(void) {
        delete[] mDisplayName;
    }

    PhoneView(const PhoneView& src) {
        CopyMembers(src);
    }
    PhoneView& operator=(const PhoneView& src) {
        if (this != &src)       // self-assignment
            CopyMembers(src);
        return *this;
    }
    void CopyMembers(const PhoneView& src) {
        // Can't memcpy and member-copy the container classes, because the
        // containers have already been constructed, and for operator= they
        // might even have stuff in them.
        mImageList = src.mImageList;
        mButtonList = src.mButtonList;
        mDisplayName = android::strdupNew(src.mDisplayName);
        mXOffset = src.mXOffset;
        mYOffset = src.mYOffset;
        mRotation = src.mRotation;
    }

    // load or unload resources, e.g. wxBitmaps from image files
    bool LoadResources(void);
    bool UnloadResources(void);

    // simple accessors
    int GetXOffset(void) const { return mXOffset; }
    int GetYOffset(void) const { return mYOffset; }
    const char* GetDisplayName(void) const { return mDisplayName; }

    // image list access
    int GetBkgImageCount(void) const;
    const LoadableImage* GetBkgImage(int idx) const;

    // find the first button that covers the specified coords
    PhoneButton* FindButtonHit(int x, int y);

    // find the first button with a matching key code
    PhoneButton* FindButtonByKey(KeyCode keyCode);

    bool ProcessAndValidate(TiXmlNode* pNode, const char* directory);
    bool ProcessImage(TiXmlNode* pNode, const char* directory);
    bool ProcessButton(TiXmlNode* pNode, const char* directory);

private:
    // background images for the phone picture that surrounds the display
    android::List<LoadableImage> mImageList;

    // list of accessible buttons, some of which have highlight graphics
    android::List<PhoneButton>  mButtonList;

    char*           mDisplayName;

    // these determine where in the image the display output goes
    int             mXOffset;
    int             mYOffset;

    // clockwise rotation of the output; sim must rotate in opposite direction
    typedef enum Rotation {
        kRotUnknown = 0,
        kRot0,
        kRot90,
        kRot180,
        kRot270,
    } Rotation;
    Rotation        mRotation;
};

/*
 * One mode of a phone.  Simple devices only have one mode.  Flip phones
 * have two (opened and closed).  Other devices might have more.  The
 * mode is communicated to the runtime because it may need to process
 * input events differently.
 */
class PhoneMode {
public:
    PhoneMode(void)
        : mName(NULL)
        {}
    ~PhoneMode(void) {
        delete[] mName;
    }

    PhoneMode(const PhoneMode& src)
        : mName(NULL)
    {
        CopyMembers(src);
    }
    PhoneMode& operator=(const PhoneMode& src) {
        if (this != &src)       // self-assignment
            CopyMembers(src);
        return *this;
    }
    void CopyMembers(const PhoneMode& src) {
        delete[] mName;
        mName = android::strdupNew(src.mName);
        mViewList = src.mViewList;
    }


    // load or unload resources for this object and all members of mViewList
    bool LoadResources(void);
    bool UnloadResources(void);

    // get the #of views
    int GetNumViews(void) const { return mViewList.size(); }
    // get the Nth display
    PhoneView* GetPhoneView(int viewNum);

    const char* GetName(void) const { return mName; }
    void SetName(const char* name) {
        delete[] mName;
        mName = android::strdupNew(name);
    }

    // load the <mode> section from the config file
    bool ProcessAndValidate(TiXmlNode* pNode, const char* directory);

private:
    char*           mName;

    android::List<PhoneView> mViewList;
};

/*
 * This holds the data for one device.
 *
 * Each device may have multiple "modes", e.g. a flip-phone that can be
 * open or shut.  Each mode has different configurations for the visible
 * displays and active keys.
 */
class PhoneData {
public:
    PhoneData(void) :
        mName(NULL), mTitle(NULL), mDirectory(NULL)
        {}
    virtual ~PhoneData(void) {
        delete[] mName;
        delete[] mTitle;
        delete[] mDirectory;
    }

    PhoneData(const PhoneData& src)
        : mName(NULL), mTitle(NULL), mDirectory(NULL)
    {
        CopyMembers(src);
    }
    PhoneData& operator=(const PhoneData& src) {
        if (this != &src)       // self-assignment
            CopyMembers(src);
        return *this;
    }
    void CopyMembers(const PhoneData& src) {
        delete[] mName;
        delete[] mTitle;
        delete[] mDirectory;
        mName = android::strdupNew(src.mName);
        mTitle = android::strdupNew(src.mTitle);
        mDirectory = android::strdupNew(src.mDirectory);
        mModeList = src.mModeList;
        mDisplayList = src.mDisplayList;
        mKeyboardList = src.mKeyboardList;
    }

    // initialize the object with the phone data in the specified dir
    bool Create(const char* directory);

    // load or unload resources, e.g. wxBitmaps from image files
    bool LoadResources(void);
    bool UnloadResources(void);

    // simple accessors
    const char* GetName(void) const { return mName; }
    void SetName(const char* name) {
        delete[] mName;
        mName = android::strdupNew(name);
    }
    const char* GetTitle(void) const { return mTitle; }
    void SetTitle(const char* title) {
        delete[] mTitle;
        mTitle = android::strdupNew(title);
    }
    const char* GetDirectory(void) const { return mDirectory; }
    void SetDirectory(const char* dir) {
        delete[] mDirectory;
        mDirectory = android::strdupNew(dir);
    }

    
    // get number of modes
    int GetNumModes(void) const { return mModeList.size(); }
    // get the specified mode object
    PhoneMode* GetPhoneMode(int idx);
    PhoneMode* GetPhoneMode(const char* modeName);

    // get number of displays
    int GetNumDisplays(void) const { return mDisplayList.size(); }
    // get the specified display object
    PhoneDisplay* GetPhoneDisplay(int idx);
    PhoneDisplay* GetPhoneDisplay(const char* displayName);
    // get the index of the matching display
    int GetPhoneDisplayIndex(const char* displayName);

    // get number of keyboards
    int GetNumKeyboards(void) const { return mKeyboardList.size(); }
    // get the specified display object
    PhoneKeyboard* GetPhoneKeyboard(int idx);
    
private:
    bool ProcessAndValidate(TiXmlDocument* pDoc);
    bool ProcessDevice(TiXmlNode* pNode);
    bool ProcessTitle(TiXmlNode* pNode);

    char*           mName;
    char*           mTitle;
    char*           mDirectory;

    android::List<PhoneMode> mModeList;
    android::List<PhoneDisplay> mDisplayList;
    android::List<PhoneKeyboard> mKeyboardList;
};

#endif // _SIM_PHONE_DATA_H