/**
 * @file WelllogRound.h
 * @brief 测井对象基类
 */

#ifndef PAI_FRAME_IOSERVICE_WELLLOGROUND_H
#define PAI_FRAME_IOSERVICE_WELLLOGROUND_H

#include <string>
#include <vector>
#include "DataObject.h"
// #include "WelllogCurve.h"
// #include "CoreImg.h"
// #include "CorePhysics.h"
// #include "DrillCore.h"
// #include "Gujing1Result.h"
// #include "SwallCore.h"
// #include "OgResult.h"
// #include "CoreDesc.h"
// #include "Wavefile.h"
// #include "Geostratum.h"
// #include "OgResult2.h"
// #include "Zone.h"
#include "OSGDataModel.h"
#include "MemRdWt.h"
namespace pai {
namespace ios {
namespace welllog {


class OSGDATAMODEL_EXPORT TableDataName
{
public:
    long long GetTableID() const
    {
        return m_TableID;
    }
	std::string GetTableName() const
	{
		return m_TableName;
	}
	std::string GetTableDataTableName() const
	{
		return m_TableDataTableName;
	}
	void SetTableID(long long  tableID)
	{
		this->m_TableID = tableID;
	}
	void SetTableName(std::string tableName)
	{
		this->m_TableName = tableName;
	}
	void SetTableDataTableName(std::string tableDataTableName)
	{
		this->m_TableDataTableName = tableDataTableName;
	}
private:
	long long m_TableID;	///<表数据ID
	std::string m_TableName;	///<表数据名
	std::string m_TableDataTableName; ///<表格数据所在的表名
};

/**
 *@class WelllogRound
 *@brief 定义井次类
 */
class OSGDATAMODEL_EXPORT WelllogRound : public DataObject
{
public:
	/**
	 * @brief 构造函数
	 */
	WelllogRound():DataObject(){
		Init();
	}
	void Init()
	{
		memset(&filemessage,0,sizeof(filemessage));
		m_CompanyName="";								///<测井公司名
		m_Team="";								        ///<测井小队
		m_Operator="";									///<操作员
		m_Date="";										///<测井日期
		m_Serial="";								    ///<测井系列
		m_Item="";									    ///<测井项目
		m_MudType="";									///<泥浆类型
		m_MudViscosity=0;							        ///<泥浆粘度
		m_WaterLoss=0;							            ///<失水量
		m_Density=0;							            ///<泥浆密度
		m_Resi=0;							                ///<泥浆电阻率
		m_Temp=0;							                ///<泥浆温度
		TopDepth=0;
		BottomDepth=0;
		m_INTLog="";									///<测井井段
		m_NITINT="";									///<解释井段
		m_TempBot=0; 									    ///<井底温度
		m_IntProg="";								    ///<解释程序
		m_InteDress="";								///<解释员
		m_Audit="";									///<审核
		m_Remark="";                                   ///<备注
		m_name="";
	};

	void SetTopDepth(float dep)
    {
        this->TopDepth = dep;
    }

    void SetBottomDepth(float dep)
    {
        this->BottomDepth = dep;
    }

	float GetTopDepth()
    {
        return TopDepth;
    }

    float GetBottomDepth()
    {
        return BottomDepth;
    }

	/**
	 * @brief 析构函数
	 */
	virtual ~WelllogRound()
	{
	}
	/**
	 * @brief 拷贝构造函数
	 */
	WelllogRound(const WelllogRound& welllogRound);
	/**
	 * @brief 赋值
	 */
	WelllogRound & operator=(const WelllogRound& welllogRound);
	/**
	 * @brief 保存数据
	 */
	virtual void Save();

	/**
	 * @brief 根据ID获取对象信息
	 * @param[in] id 数据ID
	 */
	virtual void Get(long long id);
	/**
	 * @brief 修改数据
	 */
	virtual void Update();
	/**
	 * @brief 删除数据
	 * @param[in] id 数据ID
	 */
    virtual void Delete(long long id = 0);
    // /**
    //  * @brief 获得该井次下所有的曲线
    //  * @param[out] infos 曲线列表
    //  */
    // void GetWelllogCurve(std::vector<WelllogCurve>& infos);
	
    // /**
    // * @brief 同时保存多条曲线
    // * @param[in] welllogcurves 曲线列表
    // */
    // void SaveWelllogCurve(std::vector<WelllogCurve>& welllogcurves);

	/**
	 * @brief 获得该井次下所有表
	 * @param[out] infos 井次下所有表
	 */
    // void GetTableDataName(std::vector<TableDataName>& infos);

    // /**
    //  * @brief 获得该井次下所有的岩心图片数据
    //  * @param[out] coreimgs 所有的岩心图片数据
    //  */
    // void GetCoreimg(std::vector<Coreimg>& coreimgs);

    // /**
    // * @brief 同时保存多条岩心图片数据
    // * @param[in] coreimgs 多条岩心图片数据
    // */
    // void SaveCoreimg(std::vector<Coreimg>& coreimgs);

    // /**
    //  * @brief 获得该井次下所有的物性分析数据
    //  * @param[out] corephysicss 物性分析数据
    //  */
    // void GetCorePhysics(std::vector<CorePhysics>& corephysicss);

    // /**
    // * @brief 同时保存多条物性分析数据
    // * @param[in] corephysicss 物性分析数据
    // */
    // void SaveCorePhysics(std::vector<CorePhysics>& corephysicss);

    // /**
    //  * @brief 获得该井次下所有的钻井取心数据
    //  * @param[out] drillcores 钻井取心数据
    //  */
    // void GetDrillCore(std::vector<DrillCore>& drillcores);

    // /**
    // * @brief 同时保存多条钻井取心数据
    // * @param[in] drillcores 钻井取心数据
    // */
    // void SaveDrillCore(std::vector<DrillCore>& drillcores);

    // /**
    //  * @brief 获得该井次下所有的固井结论数据
    //  * @param[out] gujing1results 固井结论数据
    //  */
    // void GetGujing1Result(std::vector<Gujing1Result>& gujing1results);

    // /**
    // * @brief 同时保存多条固井结论数据
    // * @param[in] gujing1results 固井结论数据
    // */
    // void SaveGujing1Result(std::vector<Gujing1Result>& gujing1results);

    // /**
    //  * @brief 获得该井次下所有的井壁取心数据
    //  * @param[out] swallcores 井壁取心数据
    //  */
    // void GetSwallCore(std::vector<SwallCore>& swallcores);

    // /**
    // * @brief 同时保存多条井壁取心数据
    // * @param[in] swallcores 井壁取心数据
    // */
    // void SaveSwallCore(std::vector<SwallCore>& swallcores);

    // /**
    //  * @brief 获得该井次下所有的油气结论数据
    //  * @param[out] ogresults 油气结论数据
    //  */
    // void GetOgResult(std::vector<OgResult>& ogresults);

    // /**
    // * @brief 同时保存多条油气结论数据
    // * @param[in] ogresults 油气结论数据
    // */
    // void SaveOgResult(std::vector<OgResult>& ogresults);

    // /**
    //  * @brief 获得该井次下所有的岩心描述数据
    //  * @param[out] coredescs 岩心描述数据
    //  */
    // void GetCoreDesc(std::vector<CoreDesc>& coredescs);

    // /**
    // * @brief 同时保存多条岩心描述数据
    // * @param[in] coredescs 岩心描述数据
    // */
    // void SaveCoreDesc(std::vector<CoreDesc>& coredescs);

    // /**
    //  * @brief 获得该井次下所有的地质分层数据
    //  * @param[out] geostratums 地质分层数据
    //  */
    // void GetGeostratum(std::vector<Geostratum>& geostratums);

    // /**
    //  * @brief 同时保存多条地质分层数据
    //  * @param[in] geostratums 地质分层数据
    //  */
    // void SaveGeostratum(std::vector<Geostratum>& geostratums);

    // /**
    //  * @brief 获得该井次下所有的二次解释结论数据
    //  * @param[out] ogresult2s 二次解释结论数据
    //  */
    // void GetOgResult2(std::vector<OgResult2>& ogresult2s);

    // /**
    // * @brief 同时保存多条二次解释结论数据
    // * @param[in] ogresult2s 二次解释结论数据
    // */
    // void SaveOgResult2(std::vector<OgResult2>& ogresult2s);

    // /**
    //  * @brief 获得该井次下所有的多维曲线索引
    //  * @param[out] wavefiles 多维曲线索引
    //  */
    // void GetWavefile(std::vector<Wavefile>& wavefiles);

    // /**
    //  * @brief 同时保存多条多维曲线索引
    //  * @param[in] wavefiles 多维曲线索引
    //  */
    // void SaveWavefile(std::vector<Wavefile>& wavefiles);

    // /**
    //  * @brief 获得该井次下所有的层段数据
    //  * @param[out] zones 层段数据
    //  */
    // void GetZone(std::vector<Zone>& zones);

    // /**
    // * @brief 同时保存多条层段数据
    // * @param[in] zones 层段数据
    // */
    // void SaveZone(std::vector<Zone>& zones);

public:
    std::string GetAudit() const
    {
        return m_Audit;
    }

    std::string GetCompanyName() const
    {
        return m_CompanyName;
    }

    std::string GetDate() const
    {
        return m_Date;
    }

    float GetDensity() const
    {
        return m_Density;
    }

    std::string GetINTLog() const
    {
        return m_INTLog;
    }

    std::string GetIntProg() const
    {
        return m_IntProg;
    }

    std::string GetInteDress() const
    {
        return m_InteDress;
    }

    std::string GetItem() const
    {
        return m_Item;
    }

    std::string GetMudType() const
    {
        return m_MudType;
    }

    float GetMudViscosity() const
    {
        return m_MudViscosity;
    }

    std::string GetNITINT() const
    {
        return m_NITINT;
    }

    std::string GetOperator() const
    {
        return m_Operator;
    }

    std::string GetRemark() const
    {
        return m_Remark;
    }

    float GetResi() const
    {
        return m_Resi;
    }

    std::string GetSerial() const
    {
        return m_Serial;
    }

    std::string GetTeam() const
    {
        return m_Team;
    }

    float GetTemp() const
    {
        return m_Temp;
    }

    float GetTempBot() const
    {
        return m_TempBot;
    }

    float GetWaterLoss() const
    {
        return m_WaterLoss;
    }

    void SetAudit(std::string audit)
    {
        this->m_Audit = audit;
    }

    void SetCompanyName(std::string companyName)
    {
        this->m_CompanyName = companyName;
    }

    void SetDate(std::string mdate)
    {
        this->m_Date = mdate;
    }

    void SetDensity(float density)
    {
        this->m_Density = density;
    }

    void SetINTLog(std::string mINTLog)
    {
        this->m_INTLog = mINTLog;
    }

    void SetIntProg(std::string intProg)
    {
        this->m_IntProg = intProg;
    }

    void SetInteDress(std::string inteDress)
    {
        this->m_InteDress = inteDress;
    }

    void SetItem(std::string item)
    {
        this->m_Item = item;
    }

    void SetMudType(std::string mudType)
    {
        this->m_MudType = mudType;
    }

    void SetMudViscosity(float mudViscosity)
    {
        this->m_MudViscosity = mudViscosity;
    }

    void SetNITINT(std::string mNITINT)
    {
        this->m_NITINT = mNITINT;
    }

    void SetOperator(std::string moperator)
    {
        this->m_Operator = moperator;
    }

    void SetRemark(std::string remark)
    {
        this->m_Remark = remark;
    }

    void SetResi(float resi)
    {
        this->m_Resi = resi;
    }

    void SetSerial(std::string serial)
    {
        this->m_Serial = serial;
    }

    void SetTeam(std::string team)
    {
        this->m_Team = team;
    }

    void SetTemp(float temp)
    {
        this->m_Temp = temp;
    }

    void SetTempBot(float tempBot)
    {
        this->m_TempBot = tempBot;
    }

    void SetWaterLoss(float waterLoss)
    {
        this->m_WaterLoss = waterLoss;
    }

	void LoadMeesge(QString filename)
	{
		if(filename=="") return;
		CMemRdWt *logio=new CMemRdWt();
		if(filename==""||!logio->Open(filename.toStdString().c_str(),CSlfIO::modeRead))
		{
			delete logio; 
//			QMessageBox::information(NULL,"提示","SLF文件打开失败，请检查！！",QMessageBox::Yes);
			return;
		}
		logio->GetFileMessage(filemessage);
		delete logio;
	}

	void SaveMeesge(QString filename)
	{
		if(filename=="") return;
		CMemRdWt *logio=new CMemRdWt();
		if(filename==""||!logio->Open(filename.toStdString().c_str(),CSlfIO::modeReadWrite))
		{
			delete logio; 
//			QMessageBox::information(NULL,"提示","SLF文件打开失败，请检查！！",QMessageBox::Yes);
			return;
		}
		logio->SetFileMessage(filemessage);
		delete logio;
	}

private:
	std::string m_CompanyName;								///<测井公司名
	std::string m_Team;								        ///<测井小队
	std::string m_Operator;									///<操作员
	std::string m_Date;										///<测井日期
	std::string m_Serial;								    ///<测井系列
	std::string m_Item;									    ///<测井项目
	std::string m_MudType;									///<泥浆类型
	float m_MudViscosity;							        ///<泥浆粘度
	float m_WaterLoss;							            ///<失水量
	float m_Density;							            ///<泥浆密度
	float m_Resi;							                ///<泥浆电阻率
	float m_Temp;							                ///<泥浆温度
	std::string m_INTLog;									///<测井井段
	std::string m_NITINT;									///<解释井段
	float m_TempBot; 									    ///<井底温度
	std::string m_IntProg;								    ///<解释程序
	std::string m_InteDress;								///<解释员
	std::string m_Audit;									///<审核
	std::string m_Remark;                                   ///<备注
	float TopDepth;
	float BottomDepth;
	std::string m_name;
	Slf_FILE_MESSAGE filemessage;
};

}
}
}

#endif