path: root/indra/newview/llfloaterreporter.cpp

/**
 * @file llfloaterreporter.cpp
 * @brief Abuse reports.
 *
 * $LicenseInfo:firstyear=2002&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "llviewerprecompiledheaders.h"

// self include
#include "llfloaterreporter.h"

#include <sstream>

// linden library includes
#include "llassetstorage.h"
#include "llavatarnamecache.h"
#include "llcachename.h"
#include "llcallbacklist.h"
#include "llcheckboxctrl.h"
#include "llfontgl.h"
#include "llimagepng.h"
#include "llimagej2c.h"
#include "llinventory.h"
#include "llnotificationsutil.h"
#include "llstring.h"
#include "llsys.h"
#include "llfilesystem.h"
#include "mean_collision_data.h"
#include "message.h"
#include "v3math.h"

// viewer project includes
#include "llagent.h"
#include "llbutton.h"
#include "llfloaterreg.h"
#include "lltexturectrl.h"
#include "lltexteditor.h"
#include "llscrolllistctrl.h"
#include "lldispatcher.h"
#include "llviewerobject.h"
#include "llviewerregion.h"
#include "llcombobox.h"
#include "lltooldraganddrop.h"
#include "lluiconstants.h"
#include "lluploaddialog.h"
#include "llcallingcard.h"
#include "llviewerobjectlist.h"
#include "lltoolobjpicker.h"
#include "lltoolmgr.h"
#include "llresourcedata.h"     // for LLResourceData
#include "llslurl.h"
#include "llviewerwindow.h"
#include "llviewertexturelist.h"
#include "llworldmap.h"
#include "llfilepicker.h"
#include "llfloateravatarpicker.h"
#include "lldir.h"
#include "llselectmgr.h"
#include "llversioninfo.h"
#include "lluictrlfactory.h"
#include "llviewercontrol.h"
#include "llviewernetwork.h"

#include "llagentui.h"

#include "lltrans.h"
#include "llexperiencecache.h"

#include "llcorehttputil.h"
#include "llviewerassetupload.h"

const std::string SCREEN_PREV_FILENAME = "screen_report_last.png";

//=========================================================================
//-----------------------------------------------------------------------------
// Support classes
//-----------------------------------------------------------------------------
class LLARScreenShotUploader : public LLResourceUploadInfo
{
public:
    LLARScreenShotUploader(LLSD report, LLUUID assetId, LLAssetType::EType assetType);

    virtual LLSD        prepareUpload();
    virtual LLSD        generatePostBody();
    virtual LLUUID      finishUpload(LLSD &result);

    virtual bool        showInventoryPanel() const { return false; }
    virtual std::string getDisplayName() const { return "Abuse Report"; }

private:

    LLSD    mReport;
};

LLARScreenShotUploader::LLARScreenShotUploader(LLSD report, LLUUID assetId, LLAssetType::EType assetType) :
    LLResourceUploadInfo(assetId, assetType, "Abuse Report"),
    mReport(report)
{
}

LLSD LLARScreenShotUploader::prepareUpload()
{
    return LLSD().with("success", LLSD::Boolean(true));
}

LLSD LLARScreenShotUploader::generatePostBody()
{   // The report was pregenerated and passed in the constructor.
    return mReport;
}

LLUUID LLARScreenShotUploader::finishUpload(LLSD &result)
{
    /* *TODO$: Report success or failure. Carried over from previous todo on responder*/
    return LLUUID::null;
}


//=========================================================================
//-----------------------------------------------------------------------------
// Globals
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Member functions
//-----------------------------------------------------------------------------

LLFloaterReporter::LLFloaterReporter(const LLSD& key)
:   LLFloater(key),
    mReportType(COMPLAINT_REPORT),
    mObjectID(),
    mScreenID(),
    mAbuserID(),
    mOwnerName(),
    mDeselectOnClose( false ),
    mPicking( false),
    mPosition(),
    mCopyrightWarningSeen( false ),
    mResourceDatap(new LLResourceData()),
    mAvatarNameCacheConnection()
{
    gIdleCallbacks.addFunction(onIdle, this);
}

// virtual
bool LLFloaterReporter::postBuild()
{
    LLSLURL slurl;
    LLAgentUI::buildSLURL(slurl);
    getChild<LLUICtrl>("abuse_location_edit")->setValue(slurl.getSLURLString());

    enableControls(true);

    // convert the position to a string
    LLVector3d pos = gAgent.getPositionGlobal();
    LLViewerRegion *regionp = gAgent.getRegion();
    if (regionp)
    {
        getChild<LLUICtrl>("sim_field")->setValue(regionp->getName());
        pos -= regionp->getOriginGlobal();
    }
    setPosBox(pos);

    // Default text to be blank
    getChild<LLUICtrl>("object_name")->setValue(LLStringUtil::null);
    getChild<LLUICtrl>("owner_name")->setValue(LLStringUtil::null);
    mOwnerName = LLStringUtil::null;

    getChild<LLUICtrl>("summary_edit")->setFocus(true);

    mDefaultSummary = getChild<LLUICtrl>("details_edit")->getValue().asString();

    // abuser name is selected from a list
    LLUICtrl* le = getChild<LLUICtrl>("abuser_name_edit");
    le->setEnabled( false );

    setPosBox((LLVector3d)mPosition.getValue());
    LLButton* pick_btn = getChild<LLButton>("pick_btn");
    pick_btn->setImages(std::string("tool_face.tga"),
                        std::string("tool_face_active.tga") );
    childSetAction("pick_btn", onClickObjPicker, this);

    childSetAction("select_abuser", boost::bind(&LLFloaterReporter::onClickSelectAbuser, this));

    childSetAction("send_btn", onClickSend, this);
    childSetAction("cancel_btn", onClickCancel, this);

    // grab the user's name
    std::string reporter = LLSLURL("agent", gAgent.getID(), "inspect").getSLURLString();
    getChild<LLUICtrl>("reporter_field")->setValue(reporter);

    // request categories
    if (gAgent.getRegion()
        && gAgent.getRegion()->capabilitiesReceived())
    {
        std::string cap_url = gAgent.getRegionCapability("AbuseCategories");

        if (!cap_url.empty())
        {
            std::string lang = gSavedSettings.getString("Language");
            if (lang != "default" && !lang.empty())
            {
                cap_url += "?lc=";
                cap_url += lang;
            }
            LLCoros::instance().launch("LLFloaterReporter::requestAbuseCategoriesCoro",
                boost::bind(LLFloaterReporter::requestAbuseCategoriesCoro, cap_url, this->getHandle()));
        }
    }

    center();

    return true;
}

// virtual
LLFloaterReporter::~LLFloaterReporter()
{
    if (mAvatarNameCacheConnection.connected())
    {
        mAvatarNameCacheConnection.disconnect();
    }
    gIdleCallbacks.deleteFunction(onIdle, this);

    // child views automatically deleted
    mObjectID       = LLUUID::null;

    if (mPicking)
    {
        closePickTool(this);
    }

    mPosition.setVec(0.0f, 0.0f, 0.0f);

    delete mResourceDatap;
}

void LLFloaterReporter::onIdle(void* user_data)
{
    LLFloaterReporter* floater_reporter = (LLFloaterReporter*)user_data;
    if (floater_reporter)
    {
        static LLCachedControl<F32> screenshot_delay(gSavedSettings, "AbuseReportScreenshotDelay");
        if (floater_reporter->mSnapshotTimer.getStarted() && floater_reporter->mSnapshotTimer.getElapsedTimeF32() > screenshot_delay)
        {
            floater_reporter->mSnapshotTimer.stop();
            floater_reporter->takeNewSnapshot();
        }
    }
}

void LLFloaterReporter::enableControls(bool enable)
{
    getChildView("category_combo")->setEnabled(enable);
    getChildView("chat_check")->setEnabled(enable);
    getChildView("screenshot")->setEnabled(false);
    getChildView("pick_btn")->setEnabled(enable);
    getChildView("summary_edit")->setEnabled(enable);
    getChildView("details_edit")->setEnabled(enable);
    getChildView("send_btn")->setEnabled(enable);
    getChildView("cancel_btn")->setEnabled(enable);
}

void LLFloaterReporter::getExperienceInfo(const LLUUID& experience_id)
{
    mExperienceID = experience_id;

    if (LLUUID::null != mExperienceID)
    {
        const LLSD& experience = LLExperienceCache::instance().get(mExperienceID);
        std::stringstream desc;

        if(experience.isDefined())
        {
            setFromAvatarID(experience[LLExperienceCache::AGENT_ID]);
            desc << "Experience id: " << mExperienceID;
        }
        else
        {
            desc << "Unable to retrieve details for id: "<< mExperienceID;
        }

        LLUICtrl* details = getChild<LLUICtrl>("details_edit");
        details->setValue(desc.str());
    }
}

void LLFloaterReporter::getObjectInfo(const LLUUID& object_id)
{
    // TODO --
    // 1 need to send to correct simulator if object is not
    //   in same simulator as agent
    // 2 display info in widget window that gives feedback that
    //   we have recorded the object info
    // 3 can pick avatar ==> might want to indicate when a picked
    //   object is an avatar, attachment, or other category

    mObjectID = object_id;

    if (LLUUID::null != mObjectID)
    {
        // get object info for the user's benefit
        LLViewerObject* objectp = NULL;
        objectp = gObjectList.findObject( mObjectID );
        if (objectp)
        {
            if ( objectp->isAttachment() )
            {
                objectp = (LLViewerObject*)objectp->getRoot();
                mObjectID = objectp->getID();
            }

            // correct the region and position information
            LLViewerRegion *regionp = objectp->getRegion();
            if (regionp)
            {
                getChild<LLUICtrl>("sim_field")->setValue(regionp->getName());
                LLVector3d global_pos;
                global_pos.setVec(objectp->getPositionRegion());
                setPosBox(global_pos);
            }

            if (objectp->isAvatar())
            {
                setFromAvatarID(mObjectID);
            }
            else
            {
                // we have to query the simulator for information
                // about this object
                LLMessageSystem* msg = gMessageSystem;
                U32 request_flags = COMPLAINT_REPORT_REQUEST;
                msg->newMessageFast(_PREHASH_RequestObjectPropertiesFamily);
                msg->nextBlockFast(_PREHASH_AgentData);
                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
                msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
                msg->nextBlockFast(_PREHASH_ObjectData);
                msg->addU32Fast(_PREHASH_RequestFlags, request_flags );
                msg->addUUIDFast(_PREHASH_ObjectID,     mObjectID);
                LLViewerRegion* regionp = objectp->getRegion();
                msg->sendReliable( regionp->getHost() );
            }
        }
    }
}

void LLFloaterReporter::onClickSelectAbuser()
{
    LLView * button = findChild<LLButton>("select_abuser", true);

    LLFloater * root_floater = gFloaterView->getParentFloater(this);
    LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(boost::bind(&LLFloaterReporter::callbackAvatarID, this, _1, _2), false, true, false, root_floater->getName(), button);
    if (picker)
    {
        root_floater->addDependentFloater(picker);
    }
}

void LLFloaterReporter::callbackAvatarID(const uuid_vec_t& ids, const std::vector<LLAvatarName> names)
{
    if (ids.empty() || names.empty()) return;

    getChild<LLUICtrl>("abuser_name_edit")->setValue(names[0].getCompleteName());

    mAbuserID = ids[0];

    refresh();

}

void LLFloaterReporter::setFromAvatarID(const LLUUID& avatar_id)
{
    mAbuserID = mObjectID = avatar_id;
    std::string avatar_link = LLSLURL("agent", mObjectID, "inspect").getSLURLString();
    getChild<LLUICtrl>("owner_name")->setValue(avatar_link);

    if (mAvatarNameCacheConnection.connected())
    {
        mAvatarNameCacheConnection.disconnect();
    }
    mAvatarNameCacheConnection = LLAvatarNameCache::get(avatar_id, boost::bind(&LLFloaterReporter::onAvatarNameCache, this, _1, _2));
}

void LLFloaterReporter::onAvatarNameCache(const LLUUID& avatar_id, const LLAvatarName& av_name)
{
    mAvatarNameCacheConnection.disconnect();

    if (mObjectID == avatar_id)
    {
        mOwnerName = av_name.getCompleteName();
        getChild<LLUICtrl>("object_name")->setValue(av_name.getCompleteName());
        getChild<LLUICtrl>("object_name")->setToolTip(av_name.getCompleteName());
        getChild<LLUICtrl>("abuser_name_edit")->setValue(av_name.getCompleteName());
    }
}

void LLFloaterReporter::requestAbuseCategoriesCoro(std::string url, LLHandle<LLFloater> handle)
{
    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("requestAbuseCategoriesCoro", httpPolicy));
    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);

    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);

    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);

    if (!status || !result.has("categories")) // success = httpResults["success"].asBoolean();
    {
        LL_WARNS() << "Error requesting Abuse Categories from capability: " << url << LL_ENDL;
        return;
    }

    if (handle.isDead())
    {
        // nothing to do
        return;
    }

    LLFloater* floater = handle.get();
    LLComboBox* combo = floater->getChild<LLComboBox>("category_combo");
    if (!combo)
    {
        LL_WARNS() << "categories category_combo not found!" << LL_ENDL;
        return;
    }

    //get selection (in case capability took a while)
    S32 selection = combo->getCurrentIndex();

    // Combobox should have a "Select category" element;
    // This is a bit of workaround since there is no proper and simple way to save array of
    // localizable strings in xml along with data (value). For now combobox is initialized along
    // with placeholders, and first element is "Select category" which we want to keep, so remove
    // everything but first element.
    // Todo: once sim with capability fully releases, just remove this string and all unnecessary
    // items from combobox since they will be obsolete (or depending on situation remake this to
    // something better, for example move "Select category" to separate string)
    while (combo->remove(1));

    LLSD contents = result["categories"];

    LLSD::array_iterator i = contents.beginArray();
    LLSD::array_iterator iEnd = contents.endArray();
    for (; i != iEnd; ++i)
    {
        const LLSD &message_data(*i);
        std::string label = message_data["description_localized"];
        combo->add(label, message_data["category"]);
    }

    //restore selection
    combo->selectNthItem(selection);
}

// static
void LLFloaterReporter::onClickSend(void *userdata)
{
    LLFloaterReporter *self = (LLFloaterReporter *)userdata;

    if (self->mPicking)
    {
        closePickTool(self);
    }

    if(self->validateReport())
    {

            const int IP_CONTENT_REMOVAL = 66;
            const int IP_PERMISSONS_EXPLOIT = 37;
            LLComboBox* combo = self->getChild<LLComboBox>( "category_combo");
            int category_value = combo->getSelectedValue().asInteger();

            if ( ! self->mCopyrightWarningSeen )
            {

                std::string details_lc = self->getChild<LLUICtrl>("details_edit")->getValue().asString();
                LLStringUtil::toLower( details_lc );
                std::string summary_lc = self->getChild<LLUICtrl>("summary_edit")->getValue().asString();
                LLStringUtil::toLower( summary_lc );
                if ( details_lc.find( "copyright" ) != std::string::npos ||
                    summary_lc.find( "copyright" ) != std::string::npos  ||
                    category_value == IP_CONTENT_REMOVAL ||
                    category_value == IP_PERMISSONS_EXPLOIT)
                {
                    LLNotificationsUtil::add("HelpReportAbuseContainsCopyright");
                    self->mCopyrightWarningSeen = true;
                    return;
                }
            }
            else if (category_value == IP_CONTENT_REMOVAL)
            {
                // IP_CONTENT_REMOVAL *always* shows the dialog -
                // ergo you can never send that abuse report type.
                LLNotificationsUtil::add("HelpReportAbuseContainsCopyright");
                return;
            }

        LLUploadDialog::modalUploadDialog(LLTrans::getString("uploading_abuse_report"));
        // *TODO don't upload image if checkbox isn't checked
        std::string url = gAgent.getRegionCapability("SendUserReport");
        std::string sshot_url = gAgent.getRegionCapability("SendUserReportWithScreenshot");
        if(!url.empty() || !sshot_url.empty())
        {
            self->sendReportViaCaps(url, sshot_url, self->gatherReport());
            LLNotificationsUtil::add("HelpReportAbuseConfirm");
            self->closeFloater();
        }
        else
        {
            self->getChildView("send_btn")->setEnabled(false);
            self->getChildView("cancel_btn")->setEnabled(false);
            // the callback from uploading the image calls sendReportViaLegacy()
            self->uploadImage();
        }
    }
}


// static
void LLFloaterReporter::onClickCancel(void *userdata)
{
    LLFloaterReporter *self = (LLFloaterReporter *)userdata;

    // reset flag in case the next report also contains this text
    self->mCopyrightWarningSeen = false;

    if (self->mPicking)
    {
        closePickTool(self);
    }
    self->closeFloater();
}


// static
void LLFloaterReporter::onClickObjPicker(void *userdata)
{
    LLFloaterReporter *self = (LLFloaterReporter *)userdata;
    LLToolObjPicker::getInstance()->setExitCallback(LLFloaterReporter::closePickTool, self);
    LLToolMgr::getInstance()->setTransientTool(LLToolObjPicker::getInstance());
    self->mPicking = true;
    self->getChild<LLUICtrl>("object_name")->setValue(LLStringUtil::null);
    self->getChild<LLUICtrl>("owner_name")->setValue(LLStringUtil::null);
    self->mOwnerName = LLStringUtil::null;
    LLButton* pick_btn = self->getChild<LLButton>("pick_btn");
    if (pick_btn) pick_btn->setToggleState(true);
}


// static
void LLFloaterReporter::closePickTool(void *userdata)
{
    LLFloaterReporter *self = (LLFloaterReporter *)userdata;

    LLUUID object_id = LLToolObjPicker::getInstance()->getObjectID();
    self->getObjectInfo(object_id);

    LLToolMgr::getInstance()->clearTransientTool();
    self->mPicking = false;
    LLButton* pick_btn = self->getChild<LLButton>("pick_btn");
    if (pick_btn) pick_btn->setToggleState(false);
}


// static
void LLFloaterReporter::showFromMenu(EReportType report_type)
{
    if (COMPLAINT_REPORT != report_type)
    {
        LL_WARNS() << "Unknown LLViewerReporter type : " << report_type << LL_ENDL;
        return;
    }
    LLFloaterReporter* reporter_floater = LLFloaterReg::findTypedInstance<LLFloaterReporter>("reporter");
    if(reporter_floater && reporter_floater->isInVisibleChain())
    {
        gSavedPerAccountSettings.setBOOL("PreviousScreenshotForReport", false);
    }
    reporter_floater = LLFloaterReg::showTypedInstance<LLFloaterReporter>("reporter", LLSD());
    if (reporter_floater)
    {
        reporter_floater->setReportType(report_type);
    }
}

// static
void LLFloaterReporter::show(const LLUUID& object_id, const std::string& avatar_name, const LLUUID& experience_id)
{
    LLFloaterReporter* reporter_floater = LLFloaterReg::findTypedInstance<LLFloaterReporter>("reporter");
    if(reporter_floater && reporter_floater->isInVisibleChain())
    {
        gSavedPerAccountSettings.setBOOL("PreviousScreenshotForReport", false);
    }
    reporter_floater = LLFloaterReg::showTypedInstance<LLFloaterReporter>("reporter");
    if (avatar_name.empty())
    {
        // Request info for this object
        reporter_floater->getObjectInfo(object_id);
    }
    else
    {
        reporter_floater->setFromAvatarID(object_id);
    }
    if(experience_id.notNull())
    {
        reporter_floater->getExperienceInfo(experience_id);
    }

    // Need to deselect on close
    reporter_floater->mDeselectOnClose = true;
}



void LLFloaterReporter::showFromExperience( const LLUUID& experience_id )
{
    LLFloaterReporter* reporter_floater = LLFloaterReg::findTypedInstance<LLFloaterReporter>("reporter");
    if(reporter_floater && reporter_floater->isInVisibleChain())
    {
        gSavedPerAccountSettings.setBOOL("PreviousScreenshotForReport", false);
    }
    reporter_floater = LLFloaterReg::showTypedInstance<LLFloaterReporter>("reporter");
    reporter_floater->getExperienceInfo(experience_id);

    // Need to deselect on close
    reporter_floater->mDeselectOnClose = true;
}


// static
void LLFloaterReporter::showFromObject(const LLUUID& object_id, const LLUUID& experience_id)
{
    show(object_id, LLStringUtil::null, experience_id);
}

// static
void LLFloaterReporter::showFromAvatar(const LLUUID& avatar_id, const std::string avatar_name)
{
    show(avatar_id, avatar_name);
}

// static
void LLFloaterReporter::showFromChat(const LLUUID& avatar_id, const std::string& avatar_name, const std::string& time, const std::string& description)
{
    show(avatar_id, avatar_name);

    LLStringUtil::format_map_t args;
    args["[MSG_TIME]"] = time;
    args["[MSG_DESCRIPTION]"] = description;

    LLFloaterReporter *self = LLFloaterReg::findTypedInstance<LLFloaterReporter>("reporter");
    if (self)
    {
        std::string description = self->getString("chat_report_format", args);
        self->getChild<LLUICtrl>("details_edit")->setValue(description);
    }
}

void LLFloaterReporter::setPickedObjectProperties(const std::string& object_name, const std::string& owner_name, const LLUUID owner_id)
{
    getChild<LLUICtrl>("object_name")->setValue(object_name);
    std::string owner_link =
        LLSLURL("agent", owner_id, "inspect").getSLURLString();
    getChild<LLUICtrl>("owner_name")->setValue(owner_link);
    getChild<LLUICtrl>("abuser_name_edit")->setValue(owner_name);
    mAbuserID = owner_id;
    mOwnerName = owner_name;
}


bool LLFloaterReporter::validateReport()
{
    // Ensure user selected a category from the list
    LLSD category_sd = getChild<LLUICtrl>("category_combo")->getValue();
    U8 category = (U8)category_sd.asInteger();
    if (category == 0)
    {
        LLNotificationsUtil::add("HelpReportAbuseSelectCategory");
        return false;
    }


    if ( getChild<LLUICtrl>("abuser_name_edit")->getValue().asString().empty() )
    {
        LLNotificationsUtil::add("HelpReportAbuseAbuserNameEmpty");
        return false;
    };

    if ( getChild<LLUICtrl>("abuse_location_edit")->getValue().asString().empty() )
    {
        LLNotificationsUtil::add("HelpReportAbuseAbuserLocationEmpty");
        return false;
    };

    if ( getChild<LLUICtrl>("abuse_location_edit")->getValue().asString().empty() )
    {
        LLNotificationsUtil::add("HelpReportAbuseAbuserLocationEmpty");
        return false;
    };


    if ( getChild<LLUICtrl>("summary_edit")->getValue().asString().empty() )
    {
        LLNotificationsUtil::add("HelpReportAbuseSummaryEmpty");
        return false;
    };

    if ( getChild<LLUICtrl>("details_edit")->getValue().asString() == mDefaultSummary )
    {
        LLNotificationsUtil::add("HelpReportAbuseDetailsEmpty");
        return false;
    };
    return true;
}

LLSD LLFloaterReporter::gatherReport()
{
    LLViewerRegion *regionp = gAgent.getRegion();
    if (!regionp) return LLSD(); // *TODO handle this failure case more gracefully

    // reset flag in case the next report also contains this text
    mCopyrightWarningSeen = false;

    std::ostringstream summary;
    if (!LLGridManager::getInstance()->isInProductionGrid())
    {
        summary << "Preview ";
    }

    std::string category_name;
    LLComboBox* combo = getChild<LLComboBox>( "category_combo");
    if (combo)
    {
        category_name = combo->getSelectedItemLabel(); // want label, not value
    }

#if LL_WINDOWS
    const char* platform = "Win";
#elif LL_DARWIN
    const char* platform = "Mac";
#elif LL_LINUX
    const char* platform = "Lnx";
#else
    const char* platform = "???";
#endif



    summary << ""
        << " |" << regionp->getName() << "|"                                // region reporter is currently in.
        << " (" << getChild<LLUICtrl>("abuse_location_edit")->getValue().asString() << ")"              // region abuse occured in (freeform text - no LLRegionPicker tool)
        << " [" << category_name << "] "                                    // updated category
        << " {" << getChild<LLUICtrl>("abuser_name_edit")->getValue().asString() << "} "                    // name of abuse entered in report (chosen using LLAvatarPicker)
        << " \"" << getChild<LLUICtrl>("summary_edit")->getValue().asString() << "\"";      // summary as entered


    std::ostringstream details;

    details << "V" << LLVersionInfo::instance().getVersion() << std::endl << std::endl; // client version moved to body of email for abuse reports

    std::string object_name = getChild<LLUICtrl>("object_name")->getValue().asString();
    if (!object_name.empty() && !mOwnerName.empty())
    {
        details << "Object: " << object_name << "\n";
        details << "Owner: " << mOwnerName << "\n";
    }


    details << "Abuser name: " << getChild<LLUICtrl>("abuser_name_edit")->getValue().asString() << " \n";
    details << "Abuser location: " << getChild<LLUICtrl>("abuse_location_edit")->getValue().asString() << " \n";

    details << getChild<LLUICtrl>("details_edit")->getValue().asString();

    std::string version_string;
    version_string = llformat(
            "%s %s %s %s %s",
            LLVersionInfo::instance().getShortVersion().c_str(),
            platform,
            gSysCPU.getFamily().c_str(),
            gGLManager.mGLRenderer.c_str(),
            gGLManager.mDriverVersionVendorString.c_str());

    // only send a screenshot ID if we're asked to and the email is
    // going to LL - Estate Owners cannot see the screenshot asset
    LLUUID screenshot_id = LLUUID::null;
    screenshot_id = getChild<LLUICtrl>("screenshot")->getValue();

    LLSD report = LLSD::emptyMap();
    report["report-type"] = (U8) mReportType;
    report["category"] = getChild<LLUICtrl>("category_combo")->getValue();
    report["position"] = mPosition.getValue();
    report["check-flags"] = (U8)0; // this is not used
    report["screenshot-id"] = screenshot_id;
    report["object-id"] = mObjectID;
    report["abuser-id"] = mAbuserID;
    report["abuse-region-name"] = "";
    report["abuse-region-id"] = LLUUID::null;
    report["summary"] = summary.str();
    report["version-string"] = version_string;
    report["details"] = details.str();
    return report;
}

void LLFloaterReporter::sendReportViaLegacy(const LLSD & report)
{
    LLViewerRegion *regionp = gAgent.getRegion();
    if (!regionp) return;
    LLMessageSystem *msg = gMessageSystem;
    msg->newMessageFast(_PREHASH_UserReport);
    msg->nextBlockFast(_PREHASH_AgentData);
    msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
    msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());

    msg->nextBlockFast(_PREHASH_ReportData);
    msg->addU8Fast(_PREHASH_ReportType, report["report-type"].asInteger());
    msg->addU8(_PREHASH_Category, report["category"].asInteger());
    msg->addVector3Fast(_PREHASH_Position,  LLVector3(report["position"]));
    msg->addU8Fast(_PREHASH_CheckFlags, report["check-flags"].asInteger());
    msg->addUUIDFast(_PREHASH_ScreenshotID, report["screenshot-id"].asUUID());
    msg->addUUIDFast(_PREHASH_ObjectID, report["object-id"].asUUID());
    msg->addUUID("AbuserID", report["abuser-id"].asUUID());
    msg->addString("AbuseRegionName", report["abuse-region-name"].asString());
    msg->addUUID("AbuseRegionID", report["abuse-region-id"].asUUID());

    msg->addStringFast(_PREHASH_Summary, report["summary"].asString());
    msg->addString("VersionString", report["version-string"]);
    msg->addStringFast(_PREHASH_Details, report["details"] );

    msg->sendReliable(regionp->getHost());
}

void LLFloaterReporter::finishedARPost(const LLSD &)
{
    LLUploadDialog::modalUploadFinished();

}

void LLFloaterReporter::sendReportViaCaps(std::string url, std::string sshot_url, const LLSD& report)
{
    if(!sshot_url.empty())
    {
        // try to upload screenshot
        LLResourceUploadInfo::ptr_t uploadInfo(new  LLARScreenShotUploader(report, mResourceDatap->mAssetInfo.mUuid, mResourceDatap->mAssetInfo.mType));
        LLViewerAssetUpload::EnqueueInventoryUpload(sshot_url, uploadInfo);
    }
    else
    {
        LLCoreHttpUtil::HttpCoroutineAdapter::completionCallback_t proc = boost::bind(&LLFloaterReporter::finishedARPost, _1);
        LLUploadDialog::modalUploadDialog("Abuse Report");
        LLCoreHttpUtil::HttpCoroutineAdapter::callbackHttpPost(url, report, proc, proc);
    }
}

void LLFloaterReporter::takeScreenshot(bool use_prev_screenshot)
{
    gSavedPerAccountSettings.setBOOL("PreviousScreenshotForReport", true);
    if(!use_prev_screenshot)
    {
        std::string screenshot_filename(gDirUtilp->getLindenUserDir() + gDirUtilp->getDirDelimiter() + SCREEN_PREV_FILENAME);
        LLPointer<LLImagePNG> png_image = new LLImagePNG;
        if(png_image->encode(mImageRaw, 0.0f))
        {
            png_image->save(screenshot_filename);
        }
    }
    else
    {
        mImageRaw = mPrevImageRaw;
    }

    LLPointer<LLImageJ2C> upload_data = LLViewerTextureList::convertToUploadFile(mImageRaw);

    // create a resource data
    mResourceDatap->mInventoryType = LLInventoryType::IT_NONE;
    mResourceDatap->mNextOwnerPerm = 0; // not used
    mResourceDatap->mExpectedUploadCost = 0; // we expect that abuse screenshots are free
    mResourceDatap->mAssetInfo.mTransactionID.generate();
    mResourceDatap->mAssetInfo.mUuid = mResourceDatap->mAssetInfo.mTransactionID.makeAssetID(gAgent.getSecureSessionID());

    if (COMPLAINT_REPORT == mReportType)
    {
        mResourceDatap->mAssetInfo.mType = LLAssetType::AT_TEXTURE;
        mResourceDatap->mPreferredLocation = LLFolderType::EType(LLResourceData::INVALID_LOCATION);
    }
    else
    {
        LL_WARNS() << "Unknown LLFloaterReporter type" << LL_ENDL;
    }
    mResourceDatap->mAssetInfo.mCreatorID = gAgentID;
    mResourceDatap->mAssetInfo.setName("screenshot_name");
    mResourceDatap->mAssetInfo.setDescription("screenshot_descr");

    // store in cache
    LLFileSystem j2c_file(mResourceDatap->mAssetInfo.mUuid, mResourceDatap->mAssetInfo.mType, LLFileSystem::WRITE);
    j2c_file.write(upload_data->getData(), upload_data->getDataSize());

    // store in the image list so it doesn't try to fetch from the server
    LLPointer<LLViewerFetchedTexture> image_in_list =
        LLViewerTextureManager::getFetchedTexture(mResourceDatap->mAssetInfo.mUuid);
    image_in_list->createGLTexture(0, mImageRaw, 0, true, LLGLTexture::OTHER);

    // the texture picker then uses that texture
    LLTextureCtrl* texture = getChild<LLTextureCtrl>("screenshot");
    if (texture)
    {
        texture->setImageAssetID(mResourceDatap->mAssetInfo.mUuid);
        texture->setDefaultImageAssetID(mResourceDatap->mAssetInfo.mUuid);
        texture->setCaption(getString("Screenshot"));
    }
}

void LLFloaterReporter::takeNewSnapshot()
{
    childSetEnabled("send_btn", true);
    mImageRaw = new LLImageRaw;
    const S32 IMAGE_WIDTH = 1024;
    const S32 IMAGE_HEIGHT = 768;

    // Take a screenshot, but don't draw this floater.
    setVisible(false);
    if (!gViewerWindow->rawSnapshot(mImageRaw,IMAGE_WIDTH, IMAGE_HEIGHT, true, false, true /*UI*/, true, false))
    {
        LL_WARNS() << "Unable to take screenshot" << LL_ENDL;
        setVisible(true);
        return;
    }
    setVisible(true);

    if(gSavedPerAccountSettings.getBOOL("PreviousScreenshotForReport"))
    {
        std::string screenshot_filename(gDirUtilp->getLindenUserDir() + gDirUtilp->getDirDelimiter() + SCREEN_PREV_FILENAME);
        mPrevImageRaw = new LLImageRaw;
        LLPointer<LLImagePNG> start_image_png = new LLImagePNG;
        if(start_image_png->load(screenshot_filename))
        {
            if (start_image_png->decode(mPrevImageRaw, 0.0f))
            {
                LLNotificationsUtil::add("LoadPreviousReportScreenshot", LLSD(), LLSD(), boost::bind(&LLFloaterReporter::onLoadScreenshotDialog,this, _1, _2));
                return;
            }
        }
    }
    takeScreenshot();
}


void LLFloaterReporter::onOpen(const LLSD& key)
{
    childSetEnabled("send_btn", false);
    //Time delay to avoid UI artifacts. MAINT-7067
    mSnapshotTimer.start();
}

void LLFloaterReporter::onLoadScreenshotDialog(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
    takeScreenshot(option == 0);
}

void LLFloaterReporter::uploadImage()
{
    LL_INFOS() << "*** Uploading: " << LL_ENDL;
    LL_INFOS() << "Type: " << LLAssetType::lookup(mResourceDatap->mAssetInfo.mType) << LL_ENDL;
    LL_INFOS() << "UUID: " << mResourceDatap->mAssetInfo.mUuid << LL_ENDL;
    LL_INFOS() << "Name: " << mResourceDatap->mAssetInfo.getName() << LL_ENDL;
    LL_INFOS() << "Desc: " << mResourceDatap->mAssetInfo.getDescription() << LL_ENDL;

    gAssetStorage->storeAssetData(mResourceDatap->mAssetInfo.mTransactionID,
                                    mResourceDatap->mAssetInfo.mType,
                                    LLFloaterReporter::uploadDoneCallback,
                                    (void*)mResourceDatap, true);
}


// static
void LLFloaterReporter::uploadDoneCallback(const LLUUID &uuid, void *user_data, S32 result, LLExtStat ext_status) // StoreAssetData callback (fixed)
{
    LLUploadDialog::modalUploadFinished();

    LLResourceData* data = (LLResourceData*)user_data;

    if(result < 0)
    {
        LLSD args;
        args["REASON"] = std::string(LLAssetStorage::getErrorString(result));
        LLNotificationsUtil::add("ErrorUploadingReportScreenshot", args);

        std::string err_msg("There was a problem uploading a report screenshot");
        err_msg += " due to the following reason: " + args["REASON"].asString();
        LL_WARNS() << err_msg << LL_ENDL;
        return;
    }

    if (data->mPreferredLocation != LLResourceData::INVALID_LOCATION)
    {
        LL_WARNS() << "Unknown report type : " << data->mPreferredLocation << LL_ENDL;
    }

    LLFloaterReporter *self = LLFloaterReg::findTypedInstance<LLFloaterReporter>("reporter");
    if (self)
    {
        self->mScreenID = uuid;
        LL_INFOS() << "Got screen shot " << uuid << LL_ENDL;
        self->sendReportViaLegacy(self->gatherReport());
        LLNotificationsUtil::add("HelpReportAbuseConfirm");
        self->closeFloater();
    }
}


void LLFloaterReporter::setPosBox(const LLVector3d &pos)
{
    mPosition.setVec(pos);
    std::string pos_string = llformat("{%.1f, %.1f, %.1f}",
        mPosition.mV[VX],
        mPosition.mV[VY],
        mPosition.mV[VZ]);
    getChild<LLUICtrl>("pos_field")->setValue(pos_string);
}

void LLFloaterReporter::onClose(bool app_quitting)
{
    mSnapshotTimer.stop();
    gSavedPerAccountSettings.setBOOL("PreviousScreenshotForReport", app_quitting);
}