#include "StabCalculation/StabCalculation.h"
#include <unordered_set>
#include "XmlSerialization.h"
#include "StabCalculation/XmlTableHelper.h"



// 静态成员变量初始化

std::set<std::string> StabCalcBaseData::m_lwtsumID = {
"船体钢料汇总", "木作舾装汇总", "机电设备汇总", "固定压载汇总",
"其他重量汇总", "空船汇总"
};

std::vector<BInf> StabCalcBaseData::binf_data_grid_view;
std::vector<Shell> StabCalcBaseData::shell_data_grid_view;
std::vector<Compartment> StabCalcBaseData::compartment_data_grid_view;
std::vector<FloodPoint> StabCalcBaseData::flood_point_data_grid_view;
std::vector<ImmersionPoint> StabCalcBaseData::immersion_point_data_grid_view;
std::vector<LimitStaticPoint> StabCalcBaseData::limit_static_point_data_grid_view;
std::vector<Deckline> StabCalcBaseData::deckline_data_grid_view;
std::vector<LWT> StabCalcBaseData::lwt_data_grid_view;
std::vector<PartialLoad> StabCalcBaseData::partial_load_data_grid_view;
std::vector<PartialLoadWeight> StabCalcBaseData::partial_load_weight_data_grid_view;
std::vector<PartialLoadFreeSurf> StabCalcBaseData::partial_load_free_surf_data_grid_view;
std::vector<PartialLoadBulk> StabCalcBaseData::partial_load_bulk_data_grid_view;
std::vector<PartialLoadPerson> StabCalcBaseData::partial_load_person_data_grid_view;
std::vector<PartialLoadIce> StabCalcBaseData::partial_load_ice_data_grid_view;
std::vector<WindFixed> StabCalcBaseData::wind_fixed_data_grid_view;
std::vector<WindNonFixed> StabCalcBaseData::wind_non_fixed_data_grid_view;
std::vector<Case> StabCalcBaseData::case_data_grid_view;
std::vector<AllowNM> StabCalcBaseData::allow_nm_data_grid_view;
std::vector<DamCase> StabCalcBaseData::dam_case_data_grid_view;
std::vector<DamCompartment> StabCalcBaseData::dam_compartment_data_grid_view;
std::vector<DamCaseProb> StabCalcBaseData::dam_case_prob_data_grid_view;
std::vector<DamRegion> StabCalcBaseData::dam_region_data_grid_view;
std::vector<CompExtent> StabCalcBaseData::comp_extent_data_grid_view;
std::vector<DamCompartmentProb> StabCalcBaseData::dam_comp_prob_data_grid_view;
std::vector<IncliningDraft> StabCalcBaseData::inclining_draft_data_grid_view;
std::vector<IncliningStatus> StabCalcBaseData::inclining_status_data_grid_view;
std::vector<IncliningExtraWeight> StabCalcBaseData::inclining_extra_weight_data_grid_view;
std::vector<IncliningRelocateWeight> StabCalcBaseData::inclining_relocate_weight_data_grid_view;
std::vector<IncliningAbsentWeight> StabCalcBaseData::inclining_absent_weight_data_grid_view;
std::vector<IncliningTank> StabCalcBaseData::inclining_tank_data_grid_view;
std::vector<IncliningMobileWeight> StabCalcBaseData::inclining_mobile_weight_data_grid_view;
std::vector<IncliningDevice> StabCalcBaseData::inclining_device_data_grid_view;
std::vector<IncliningCase> StabCalcBaseData::inclining_case_data_grid_view;
std::vector<IncliningRecord> StabCalcBaseData::inclining_record_data_grid_view;
std::vector<XLabel> StabCalcBaseData::xlabel_data_grid_view;
std::vector<PartialLoadItem> StabCalcBaseData::partial_load_item_data_grid_view;


std::vector<Pull> StabCalcBaseData::Pull_data_grid_view;
std::vector<Jet> StabCalcBaseData::Jet_data_grid_view;
std::vector<Lift> StabCalcBaseData::Lift_data_grid_view;
std::vector<Sidesway> StabCalcBaseData::Sidesway_data_grid_view;
std::vector<Pile> StabCalcBaseData::Pile_data_grid_view;
std::vector<Mud> StabCalcBaseData::Mud_data_grid_view;
std::vector<MudAsym> StabCalcBaseData::MudAsym_data_grid_view;

std::vector<StationLabel> StabCalcBaseData::station_label_data_grid_view;
std::vector<WaterlineLabel> StabCalcBaseData::waterline_label_data_grid_view;
std::vector<ButtocklineLabel> StabCalcBaseData::buttockline_label_data_grid_view;




std::string StabCalcBaseData::FindByParamID(std::string paramid)
{
    auto it = binf_data_grid_view.begin();
    for (; it != binf_data_grid_view.end(); ++it)
    {
        if (it->paramid == paramid)
        {
            return it->value;
        }
    }
    return "";
}

Compartment* StabCalcBaseData::compartment_FindByID(std::string id)
{
    auto it = StabCalcBaseData::compartment_data_grid_view.begin();
    for (; it != StabCalcBaseData::compartment_data_grid_view.end(); ++it)
    {
        if (it->id == id)
        {
            return &*it;
        }
    }
    return nullptr;
}

Case* StabCalcBaseData::Case_FindByID(std::string id)
{
    auto it = StabCalcBaseData::case_data_grid_view.begin();
    for (; it != StabCalcBaseData::case_data_grid_view.end(); ++it)
    {
        if (it->id == id)
        {
            return &*it;
        }
    }
    return nullptr;
    
}

IncliningCase* StabCalcBaseData::IncliningCase_FindByID(int id)
{
    auto it = StabCalcBaseData::inclining_case_data_grid_view.begin();
    for (; it != StabCalcBaseData::inclining_case_data_grid_view.end(); ++it)
    {
        if (it->id == id)
        {
            return &*it;
        }
    }
    return nullptr;
}

PartialLoad* StabCalcBaseData::PartialLoad_FindByID(std::string id)
{
    auto it = StabCalcBaseData::partial_load_data_grid_view.begin();
    for (; it != StabCalcBaseData::partial_load_data_grid_view.end(); ++it)
    {
        if (it->id == id)
        {
            return &*it;
        }
    }
    return nullptr;
}

WindNonFixed* StabCalcBaseData::WindNonFixed_FindByID(std::string id)
{
    auto it = StabCalcBaseData::wind_non_fixed_data_grid_view.begin();
    for (; it != StabCalcBaseData::wind_non_fixed_data_grid_view.end(); ++it)
    {
        if (it->id == id)
        {
            return &*it;
        }
    }
    return nullptr;
}


int StabCalcBaseData::fromXml()
{
    auto xmlPtr = XmlSerialization::getXmlSerializationInstance();
    // 基本信息
    xmlPtr->getBInfTableData(binf_data_grid_view);
    //船壳
    xmlPtr->getShellTableData(shell_data_grid_view);

    xmlPtr->getXLabelTableData(xlabel_data_grid_view);

    // 进水点
    xmlPtr->getFloodPointTableData(flood_point_data_grid_view);
    // 权限静倾角（出水入水点）
    xmlPtr->getLimitStaticPointTableData(limit_static_point_data_grid_view);
    // 浸没点
    xmlPtr->getImmersionPointTableData(immersion_point_data_grid_view);
    // 舱壁甲板边线
    xmlPtr->getDecklineTableData(deckline_data_grid_view);
    // 舱容
    xmlPtr->getCompartmentTableData(compartment_data_grid_view);

    // 空船重量
    xmlPtr->getLwtTableData(lwt_data_grid_view);

    xmlPtr->getPartialLoadTableData(partial_load_data_grid_view);
    xmlPtr->getPartialLoadWeightTableData(partial_load_weight_data_grid_view);
    xmlPtr->getPartialLoadFreeSurfTableData(partial_load_free_surf_data_grid_view);
    xmlPtr->getPartialLoadBulkTableData(partial_load_bulk_data_grid_view);
    xmlPtr->getPartialLoadPersonTableData(partial_load_person_data_grid_view);
    xmlPtr->getPartialLoadIceTableData(partial_load_ice_data_grid_view);

    xmlPtr->getWindFixedTableData(wind_fixed_data_grid_view);
    xmlPtr->getWindNonFixedTableData(wind_non_fixed_data_grid_view);

    xmlPtr->getCaseTableData(case_data_grid_view);

    xmlPtr->getAllowNMTableData(allow_nm_data_grid_view);

    xmlPtr->getDamCaseTableData(dam_case_data_grid_view);
    xmlPtr->getDamCompartmentTableData(dam_compartment_data_grid_view);


    xmlPtr->getDamCaseProbTableData(dam_case_prob_data_grid_view);
    xmlPtr->getDamRegionTableData(dam_region_data_grid_view);
    xmlPtr->getCompExtentTableData(comp_extent_data_grid_view);
    xmlPtr->getDamCompartmentProbTableData(dam_comp_prob_data_grid_view);


    xmlPtr->getIncliningDraftTableData(inclining_draft_data_grid_view);
    xmlPtr->getIncliningStatusTableData(inclining_status_data_grid_view);


    xmlPtr->getIncliningExtraWeightTableData(inclining_extra_weight_data_grid_view);
    xmlPtr->getIncliningRelocateWeightTableData(inclining_relocate_weight_data_grid_view);
    xmlPtr->getIncliningAbsentWeightTableData(inclining_absent_weight_data_grid_view);
    xmlPtr->getIncliningTankTableData(inclining_tank_data_grid_view);


    xmlPtr->getIncliningMobileWeightTableData(inclining_mobile_weight_data_grid_view);
    xmlPtr->getIncliningDeviceTableData(inclining_device_data_grid_view);
    xmlPtr->getIncliningCaseTableData(inclining_case_data_grid_view);
    xmlPtr->getIncliningRecordTableData(inclining_record_data_grid_view);


    xmlPtr->getStationLabelTableData(station_label_data_grid_view);
    xmlPtr->getWaterlineLabelTableData(waterline_label_data_grid_view);
    xmlPtr->getButtocklineLabelTableData(buttockline_label_data_grid_view);

    return 0;
}

int StabCalcBaseData::toXml()
{
    auto xmlPtr = XmlSerialization::getXmlSerializationInstance();
    // 基本信息
    xmlPtr->setBInfDataSet(binf_data_grid_view);
    //船壳
    xmlPtr->setShellDataSet(shell_data_grid_view);

    xmlPtr->setXLabelDataSet(xlabel_data_grid_view);
    // 进水点
    xmlPtr->setFloodPointDataSet(flood_point_data_grid_view);
    // 权限静倾角（出水入水点）
    xmlPtr->setLimitStaticPointDataSet(limit_static_point_data_grid_view);
    // 浸没点
    xmlPtr->setImmersionPointDataSet(immersion_point_data_grid_view);
    // 舱壁甲板边线
    xmlPtr->setDecklineDataSet(deckline_data_grid_view);
    // 舱容
    xmlPtr->setCompartmentDataSet(compartment_data_grid_view);

    // 空船重量
    xmlPtr->setLwtDataSet(lwt_data_grid_view);

    xmlPtr->setPartialLoadDataSet(partial_load_data_grid_view);
    xmlPtr->setPartialLoadWeightDataSet(partial_load_weight_data_grid_view);
    xmlPtr->setPartialLoadFreeSurfDataSet(partial_load_free_surf_data_grid_view);
    xmlPtr->setPartialLoadBulkDataSet(partial_load_bulk_data_grid_view);
    xmlPtr->setPartialLoadPersonDataSet(partial_load_person_data_grid_view);
    xmlPtr->setPartialLoadIceDataSet(partial_load_ice_data_grid_view);

    xmlPtr->setWindFixedDataSet(wind_fixed_data_grid_view);
    xmlPtr->setWindNonFixedDataSet(wind_non_fixed_data_grid_view);

    xmlPtr->setCaseDataSet(case_data_grid_view);

    xmlPtr->setAllowNMDataSet(allow_nm_data_grid_view);

    xmlPtr->setDamCaseDataSet(dam_case_data_grid_view);
    xmlPtr->setDamCompartmentDataSet(dam_compartment_data_grid_view);


    xmlPtr->setDamCaseProbDataSet(dam_case_prob_data_grid_view);
    xmlPtr->setDamRegionDataSet(dam_region_data_grid_view);
    xmlPtr->setCompExtentDataSet(comp_extent_data_grid_view);
    xmlPtr->setDamCompartmentProbDataSet(dam_comp_prob_data_grid_view);


    xmlPtr->setIncliningDraftDataSet(inclining_draft_data_grid_view);
    xmlPtr->setIncliningStatusDataSet(inclining_status_data_grid_view);


    xmlPtr->setIncliningExtraWeightDataSet(inclining_extra_weight_data_grid_view);
    xmlPtr->setIncliningRelocateWeightDataSet(inclining_relocate_weight_data_grid_view);
    xmlPtr->setIncliningAbsentWeightDataSet(inclining_absent_weight_data_grid_view);
    xmlPtr->setIncliningTankDataSet(inclining_tank_data_grid_view);


    xmlPtr->setIncliningMobileWeightDataSet(inclining_mobile_weight_data_grid_view);
    xmlPtr->setIncliningDeviceDataSet(inclining_device_data_grid_view);
    xmlPtr->setIncliningCaseDataSet(inclining_case_data_grid_view);
    xmlPtr->setIncliningRecordDataSet(inclining_record_data_grid_view);

    xmlPtr->setStationLabelDataSet(station_label_data_grid_view);
    xmlPtr->setWaterlineLabelDataSet(waterline_label_data_grid_view);
    xmlPtr->setButtocklineLabelDataSet(buttockline_label_data_grid_view);

    return 0;
}


void StabCalcBaseData::updateData()
{

    for (int i = 0; i < StabCalcBaseData::shell_data_grid_view.size(); i++)
    {
        StabCalcBaseData::shell_data_grid_view[i].sid = i + 1;
    }


    for (int i = 0; i < StabCalcBaseData::compartment_data_grid_view.size(); i++)
    {
        StabCalcBaseData::compartment_data_grid_view[i].sid = i + 1;
    }


    for(auto& item : StabCalcBaseData::flood_point_data_grid_view)
    {
        item.x = ChangeFSPos::ShowX(item.xsymbol);
    }
    for(auto& item : StabCalcBaseData::limit_static_point_data_grid_view)
    {
        item.x1 = ChangeFSPos::ShowX(item.xsymbol);
        item.x2 = item.x1;
    }
    for(auto& item : StabCalcBaseData::immersion_point_data_grid_view)
    {
        item.x = ChangeFSPos::ShowX(item.xsymbol);
    }
    for(auto& item : StabCalcBaseData::deckline_data_grid_view)
    {
        item.x = ChangeFSPos::ShowX(item.xsymbol);
    }
    for(auto& item : StabCalcBaseData::lwt_data_grid_view)
    {
        item.xg = ChangeFSPos::ShowX(item.xg_symbol);
        item.xa = ChangeFSPos::ShowX(item.xa_symbol);
        item.xf = ChangeFSPos::ShowX(item.xf_symbol);
    }
    for(auto& item : StabCalcBaseData::partial_load_weight_data_grid_view)
    {
        item.xg = ChangeFSPos::ShowX(item.xg_symbol);
        item.xa = ChangeFSPos::ShowX(item.xa_symbol);
        item.xf = ChangeFSPos::ShowX(item.xf_symbol);
    }
    for(auto& item : StabCalcBaseData::partial_load_ice_data_grid_view) //20201214 by czb, 结冰载荷，远洋渔船
    {
        item.xg = ChangeFSPos::ShowX(item.xg_symbol);
    }
    
    for(auto& item : StabCalcBaseData::partial_load_item_data_grid_view)
    {
        item.xg = ChangeFSPos::ShowX(item.xg_symbol);
        item.xa = ChangeFSPos::ShowX(item.xa_symbol);
        item.xf = ChangeFSPos::ShowX(item.xf_symbol);
    }
    
    for(auto& item : StabCalcBaseData::inclining_mobile_weight_data_grid_view)
    {
        item.xg = ChangeFSPos::ShowX(item.xg_symbol);
    }
    for(auto& item : StabCalcBaseData::inclining_extra_weight_data_grid_view)
    {
        item.xg = ChangeFSPos::ShowX(item.xg_symbol);
    }
    for(auto& item : StabCalcBaseData::inclining_absent_weight_data_grid_view)
    {
        item.xg = ChangeFSPos::ShowX(item.xg_symbol);
    }
    for(auto& item : StabCalcBaseData::inclining_relocate_weight_data_grid_view)
    {
        item.xg = ChangeFSPos::ShowX(item.xg_symbol);
    }
}




void BinfTabpage::convertFromJson(json& j, eBinfTabpage_Type type)
{
    //std::vector<BInf> binf_data_grid_view_tmp;
   // getDisPlayData(type, binf_data_grid_view_tmp);
    StabCalcBaseData::convertFromJson(j, "binf_data_grid_view", StabCalcBaseData::binf_data_grid_view);
    StabCalcBaseData::convertFromJson(j, "shell_data_grid_view", StabCalcBaseData::shell_data_grid_view);

}


void BinfTabpage::convertToJson(json& j, eBinfTabpage_Type type)
{
    std::vector<BInf> binf_data_grid_view_tmp;
    getDisPlayData(type, binf_data_grid_view_tmp);
    StabCalcBaseData::convertToJson(j, "binf_data_grid_view", binf_data_grid_view_tmp);
    StabCalcBaseData::convertToJson(j, "shell_data_grid_view", StabCalcBaseData::shell_data_grid_view);

   // QString data = QString::fromStdString(j.dump());
   // int a = 0;
}

void BinfTabpage::getDisPlayData(eBinfTabpage_Type type, std::vector<BInf>& binf_data_grid_view)
{
    binf_data_grid_view = StabCalcBaseData::binf_data_grid_view;
    switch (type)
    {
    case eBinfTabpage_Type_Hydro:
    {
        
        // 元素处理
        std::unordered_set<std::string> visible_set = { "XType",
                                                       "IsCatamaran",
                                                       "IsBox",
                                                       "DraftList",
                                                       "TrimList",
                                                       "AngleEvalMax",
                                                       "AngleEvalInterval" };

        binf_data_grid_view.erase(
            std::remove_if(
                binf_data_grid_view.begin(),
                binf_data_grid_view.end(),
                [&visible_set](const BInf& item)
                {
                    return visible_set.find(item.paramid) == visible_set.end(); // 使用 find() 替代 contains()
                }),
            binf_data_grid_view.end());
    }
        break;
    case eBinfTabpage_Type_TankCap:
    {
        // 元素处理
        std::unordered_set<std::string> visible_set = { "XType",
                                                       "IsCatamaran",
                                                       "IsBox",
                                                       "TankCapStep" };
        binf_data_grid_view.erase(
            std::remove_if(
                binf_data_grid_view.begin(),
                binf_data_grid_view.end(),
                [&visible_set](const BInf& item)
                {
                    return visible_set.find(item.paramid) == visible_set.end(); // 使用 find() 替代 contains()
                }),
            binf_data_grid_view.end());
    }
        break;
    case eBinfTabpage_Type_Intact:
    {
        // 元素处理
        set_binf_visible_stab(binf_data_grid_view, "Intact");
    }
        break;
    case eBinfTabpage_Type_AllowKG:
    {
        set_binf_visible_stab(binf_data_grid_view, "AllowKG");
    }
        break;
    case eBinfTabpage_Type_Damage:
    {
        // 元素处理
        set_binf_visible_stab(binf_data_grid_view, "Damage");
    }
        break;
    case eBinfTabpage_Type_DamageProb:
    {
        // 元素处理
        set_binf_visible_damage_prob(binf_data_grid_view, "DamageProb");
    }
        break;
    case eBinfTabpage_Type_Inclining:
    {
        // 元素处理
        std::unordered_set<std::string> visible_set = { "IncliningRecordNo",
                                                       "IsCatamaran",
                                                       "IncliningDensity",
                                                       "AT",
                                                       "IncliningAH0",
                                                       "IncliningMobileWeightNo",
                                                       "IncliningDeviceType",
                                                       "IncliningDeviceNo",
                                                       "IncliningAngleAlgorithm",
                                                       "IncliningGMAlgorithm" };
        binf_data_grid_view.erase(
            std::remove_if(
                binf_data_grid_view.begin(),
                binf_data_grid_view.end(),
                [&visible_set](const BInf& item)
                {
                    return visible_set.find(item.paramid) == visible_set.end(); // 使用 find() 替代 contains()
                }),
            binf_data_grid_view.end());
    }
        break;
    case eBinfTabpage_Type_Size:
        break;
    default:
        break;
    }
}

void Hydro::convertToJson(json& j)
{

    binf_tabpage1.convertToJson(j["binf_tabpage1"], eBinfTabpage_Type_Hydro);
    hydro_floodpoint_tabpage3.convertToJson(j["hydro_floodpoint_tabpage3"]);
    tank_cap_compartment_tabpage20.convertToJson(j["tank_cap_compartment_tabpage20"]);
}

void Hydro::convertFromJson(json& j)
{
    if (j.contains("binf_tabpage1"))
    {
        binf_tabpage1.convertFromJson(j["binf_tabpage1"], eBinfTabpage_Type_Hydro);
    }
    if (j.contains("hydro_floodpoint_tabpage3"))
    {
        hydro_floodpoint_tabpage3.convertFromJson(j["hydro_floodpoint_tabpage3"]);
    }
    if (j.contains("tank_cap_compartment_tabpage20"))
    {
        tank_cap_compartment_tabpage20.convertFromJson(j["tank_cap_compartment_tabpage20"]);
    }


}

void TankCap::convertToJson(json& j)
{
    binf_tabpage1.convertToJson(j["binf_tabpage1"], eBinfTabpage_Type_TankCap);
    tank_cap_compartment_tabpage20.convertToJson(j["tank_cap_compartment_tabpage20"]);
    hydro_floodpoint_tabpage3.convertToJson(j["hydro_floodpoint_tabpage3"]);
}

void TankCap::convertFromJson(json& j)
{
    if (j.contains("binf_tabpage1"))
    {
        binf_tabpage1.convertFromJson(j["binf_tabpage1"], eBinfTabpage_Type_TankCap);
    }
    if (j.contains("tank_cap_compartment_tabpage20"))
    {
        tank_cap_compartment_tabpage20.convertFromJson(j["tank_cap_compartment_tabpage20"]);
    }

    if (j.contains("hydro_floodpoint_tabpage3"))
    {
        hydro_floodpoint_tabpage3.convertFromJson(j["hydro_floodpoint_tabpage3"]);
    }
}


void Intact::convertToJson(json& j)
{

    binf_tabpage1.convertToJson(j["binf_tabpage1"], eBinfTabpage_Type_Intact);                        // 基本信息
    intact_lwt_tabpage2.convertToJson(j["intact_lwt_tabpage2"]);            // 空船重量
    intact_partial_load_tabpage1.convertToJson(j["intact_partial_load_tabpage1"]);// 装载项

    intact_wind_tabpage5.convertToJson(j["intact_wind_tabpage5"]);          // 受风项

    intact_case_tabpage6.convertToJson(j["intact_case_tabpage6"]);          // 完整工况

    allow_nm_tabpage1.convertToJson(j["allow_nm_tabpage1"]);                // 许用剪力弯矩

    tank_cap_compartment_tabpage20.convertToJson(j["tank_cap_compartment_tabpage20"]);  // 舱室

    hydro_floodpoint_tabpage3.convertToJson(j["hydro_floodpoint_tabpage3"]);  // 船型特征点

}

void Intact::convertFromJson(json& j)
{
    if (j.contains("binf_tabpage1"))
    {
        binf_tabpage1.convertFromJson(j["binf_tabpage1"], eBinfTabpage_Type_TankCap);
    }
    if (j.contains("intact_lwt_tabpage2"))
    {
        intact_lwt_tabpage2.convertFromJson(j["intact_lwt_tabpage2"]);
    }

    if (j.contains("intact_partial_load_tabpage1"))
    {
        intact_partial_load_tabpage1.convertFromJson(j["intact_partial_load_tabpage1"]);
    }

    if (j.contains("intact_wind_tabpage5"))
    {
        intact_wind_tabpage5.convertFromJson(j["intact_wind_tabpage5"]);
    }

    if (j.contains("intact_case_tabpage6"))
    {
        intact_case_tabpage6.convertFromJson(j["intact_case_tabpage6"]);
    }

    if (j.contains("allow_nm_tabpage1"))
    {
        allow_nm_tabpage1.convertFromJson(j["allow_nm_tabpage1"]);
    }

    if (j.contains("tank_cap_compartment_tabpage20"))
    {
        tank_cap_compartment_tabpage20.convertFromJson(j["tank_cap_compartment_tabpage20"]);
    }

    if (j.contains("hydro_floodpoint_tabpage3"))
    {
        hydro_floodpoint_tabpage3.convertFromJson(j["hydro_floodpoint_tabpage3"]);
    }

}



void AllowKG::convertToJson(json& j)
{
    binf_tabpage1.convertToJson(j["binf_tabpage1"], eBinfTabpage_Type_AllowKG);
}

void AllowKG::convertFromJson(json& j)
{
    if (j.contains("binf_tabpage1"))
    {
        binf_tabpage1.convertFromJson(j["binf_tabpage1"], eBinfTabpage_Type_AllowKG);
    }
}


void Damage::convertToJson(json& j)
{
    binf_tabpage1.convertToJson(j["binf_tabpage1"], eBinfTabpage_Type_Damage);
    damage_case_tabpage19.convertToJson(j["damage_case_tabpage19"]);
    tank_cap_compartment_tabpage20.convertToJson(j["tank_cap_compartment_tabpage20"]);
    hydro_floodpoint_tabpage3.convertToJson(j["hydro_floodpoint_tabpage3"]);
    intact_lwt_tabpage2.convertToJson(j["intact_lwt_tabpage2"]);
    intact_partial_load_tabpage1.convertToJson(j["intact_partial_load_tabpage1"]);
    intact_wind_tabpage5.convertToJson(j["intact_wind_tabpage5"]);
    intact_case_tabpage6.convertToJson(j["intact_case_tabpage6"]);
    allow_nm_tabpage1.convertToJson(j["allow_nm_tabpage1"]);
}

void Damage::convertFromJson(json& j)
{
    if (j.contains("binf_tabpage1"))
    {
        binf_tabpage1.convertFromJson(j["binf_tabpage1"], eBinfTabpage_Type_Damage);
    }

    if (j.contains("damage_case_tabpage19"))
    {
        damage_case_tabpage19.convertFromJson(j["damage_case_tabpage19"]);
    }

    if (j.contains("tank_cap_compartment_tabpage20"))
    {
        tank_cap_compartment_tabpage20.convertFromJson(j["tank_cap_compartment_tabpage20"]);
    }


    if (j.contains("hydro_floodpoint_tabpage3"))
    {
        hydro_floodpoint_tabpage3.convertFromJson(j["hydro_floodpoint_tabpage3"]);
    }

    if (j.contains("intact_lwt_tabpage2"))
    {
        intact_lwt_tabpage2.convertFromJson(j["intact_lwt_tabpage2"]);
    }

    if (j.contains("intact_partial_load_tabpage1"))
    {
        intact_partial_load_tabpage1.convertFromJson(j["intact_partial_load_tabpage1"]);
    }

    if (j.contains("intact_wind_tabpage5"))
    {
        intact_wind_tabpage5.convertFromJson(j["intact_wind_tabpage5"]);
    }

    if (j.contains("intact_case_tabpage6"))
    {
        intact_case_tabpage6.convertFromJson(j["intact_case_tabpage6"]);
    }

    if (j.contains("allow_nm_tabpage1"))
    {
        allow_nm_tabpage1.convertFromJson(j["allow_nm_tabpage1"]);
    }

}


void DamageProb::convertToJson(json& j)
{
    binf_tabpage1.convertToJson(j["binf_tabpage1"], eBinfTabpage_Type_DamageProb);
    damage_case_prob_tabpage.convertToJson(j["damage_case_prob_tabpage"]);
    tank_cap_compartment_tabpage20.convertToJson(j["tank_cap_compartment_tabpage20"]);
    hydro_floodpoint_tabpage3.convertToJson(j["hydro_floodpoint_tabpage3"]);
}

void DamageProb::convertFromJson(json& j)
{
    if (j.contains("binf_tabpage1"))
    {
        binf_tabpage1.convertFromJson(j["binf_tabpage1"], eBinfTabpage_Type_DamageProb);
    }

    if (j.contains("damage_case_prob_tabpage"))
    {
        damage_case_prob_tabpage.convertFromJson(j["damage_case_prob_tabpage"]);
    }

    if (j.contains("tank_cap_compartment_tabpage20"))
    {
        tank_cap_compartment_tabpage20.convertFromJson(j["tank_cap_compartment_tabpage20"]);
    }

    if (j.contains("hydro_floodpoint_tabpage3"))
    {
        hydro_floodpoint_tabpage3.convertFromJson(j["hydro_floodpoint_tabpage3"]);
    }


}


void Inclining::convertToJson(json& j)
{
    binf_tabpage1.convertToJson(j["binf_tabpage1"], eBinfTabpage_Type_Inclining);
    inclining_status_tabpage1.convertToJson(j["inclining_status_tabpage1"]);
    inclining_loading_tabpage1.convertToJson(j["inclining_loading_tabpage1"]);
    inclining_record_tabpage1.convertToJson(j["inclining_record_tabpage1"]);
}

void Inclining::convertFromJson(json& j)
{
    if (j.contains("binf_tabpage1"))
    {
        binf_tabpage1.convertFromJson(j["binf_tabpage1"], eBinfTabpage_Type_Inclining);
    }

    if (j.contains("inclining_status_tabpage1"))
    {
        inclining_status_tabpage1.convertFromJson(j["inclining_status_tabpage1"]);
    }

    if (j.contains("inclining_loading_tabpage1"))
    {
        inclining_loading_tabpage1.convertFromJson(j["inclining_loading_tabpage1"]);
    }

    if (j.contains("inclining_record_tabpage1"))
    {
        inclining_record_tabpage1.convertFromJson(j["inclining_record_tabpage1"]);
    }

}


// 数据检查-静水力
std::string Hydro::data_check(const nlohmann::json &j)
{
    std::string err;

    err = err + check_basic_inf(j);
    err = err + check_shell(j);
    err = err + check_limit_static_point(j);

    return err;
}

// 数据检查-舱容
std::string TankCap::data_check(const nlohmann::json &j)
{
    std::string err;

    err = err + check_basic_inf(j);

    const auto &compartment_j = j["tank_cap_compartment_tabpage20"]["compartment_data_grid_view"];
    if (compartment_j.size() < 1)
    {
        err = err + "\n舱室数据不能为空";
    }
    else
    {
        err = err + check_compartment(compartment_j);
    }

    return err;
}

// 数据检查-完整稳性
std::string Intact::data_check(const nlohmann::json &j)
{
    std::string err;

    err = err + check_basic_inf(j);
    // err = err + check_cr_rule(j);

    err = err + check_shell(j);
    const auto &compartment_j = j["tank_cap_compartment_tabpage20"]["compartment_data_grid_view"];

    err = err + check_compartment(compartment_j);
    err = err + check_lwt(j);
    err = err + check_wind(j);
    err = err + check_partial_load(j);
    err = err + check_partial_load_item(j);
    err = err + check_case(j);

    return err;
}

// 数据检查-许用重心高度
std::string AllowKG::data_check(const nlohmann::json &j)
{
    std::string err;

    return err;
}

// 数据检查-破损稳性
std::string Damage::data_check(const nlohmann::json &j)
{
    std::string err;

    err = err + check_basic_inf(j);
    // err = err + check_cr_rule(j);

    err = err + check_shell(j);

    const nlohmann::json &j_compartment_array = j["tank_cap_compartment_tabpage20"]["compartment_data_grid_view"];
    if (j_compartment_array.size() < 1)
    {
        err = err + "\n" + "舱室数据不能为空";
    }
    err = err + check_compartment(j_compartment_array);
    err = err + check_lwt(j);
    err = err + check_wind(j);
    err = err + check_partial_load(j);
    err = err + check_partial_load_item(j);
    err = err + check_case(j);

    return err;
}

// 数据检查-概率破损
std::string DamageProb::data_check(const nlohmann::json &j)
{
    std::string err;

    err = err + check_shell(j);

    //TODO

    return err;
}

// 数据检查-倾斜试验
std::string Inclining::data_check(const nlohmann::json &j)
{
    std::string err;

    err = err + check_shell(j);

    //TODO
    return err;
}