/******************************************************************************

 *

 * Project:  GDAL

 * Purpose:  gdal "raster clean-collar" subcommand

 * Author:   Even Rouault <even dot rouault at spatialys.com>

 *

 ******************************************************************************

 * Copyright (c) 2025, Even Rouault <even dot rouault at spatialys.com>

 *

 * SPDX-License-Identifier: MIT

 ****************************************************************************/

#include "gdalalg_raster_clean_collar.h"

#include "cpl_conv.h"

#include "cpl_vsi_virtual.h"

#include "gdal_priv.h"

#include "gdal_utils.h"

//! @cond Doxygen_Suppress

#ifndef _

#define _(x) (x)

#endif

/************************************************************************/

/*   GDALRasterCleanCollarAlgorithm::GDALRasterCleanCollarAlgorithm()   */

/************************************************************************/

GDALRasterCleanCollarAlgorithm::GDALRasterCleanCollarAlgorithm()

    : GDALAlgorithm(NAME, DESCRIPTION, HELP_URL)

{

    AddProgressArg();

    AddOpenOptionsArg(&m_openOptions);

    AddInputFormatsArg(&m_inputFormats)

        .AddMetadataItem(GAAMDI_REQUIRED_CAPABILITIES, {GDAL_DCAP_RASTER});

    AddInputDatasetArg(&m_inputDataset, GDAL_OF_RASTER);

    AddOutputDatasetArg(&m_outputDataset, GDAL_OF_RASTER,

                        /* positionalAndRequired = */ false)

        .SetPositional()

        .SetDatasetInputFlags(GADV_NAME | GADV_OBJECT);

    AddOutputFormatArg(&m_format, /* bStreamAllowed = */ false,

                       /* bGDALGAllowed = */ false)

        .AddMetadataItem(GAAMDI_REQUIRED_CAPABILITIES,

                         {GDAL_DCAP_CREATE, GDAL_DCAP_RASTER});

    AddCreationOptionsArg(&m_creationOptions);

    AddOverwriteArg(&m_overwrite);

    AddUpdateArg(&m_update);

    AddArg("color", 0,

           _("Transparent color(s): tuple of integer (like 'r,g,b'), 'black', "

             "'white'"),

           &m_color)

        .SetDefault("black")

        .SetPackedValuesAllowed(false)

        .AddValidationAction(

            [this]()

            {

                for (const auto &c : m_color)

                {

                    if (c != "white" && c != "black")

                    {

                        const CPLStringList aosTokens(

                            CSLTokenizeString2(c.c_str(), ",", 0));

                        for (const char *pszToken : aosTokens)

                        {

                            if (CPLGetValueType(pszToken) != CPL_VALUE_INTEGER)

                            {

                                ReportError(CE_Failure, CPLE_IllegalArg,

                                            "Value for 'color' should be tuple "

                                            "of integer (like 'r,g,b'), "

                                            "'black' or 'white'");

                                return false;

                            }

                        }

                    }

                }

                return true;

            });

    AddArg("color-threshold", 0,

           _("Select how far from specified transparent colors the pixel "

             "values are considered transparent."),

           &m_colorThreshold)

        .SetDefault(m_colorThreshold)

        .SetMinValueIncluded(0);

    AddArg("pixel-distance", 0,

           _("Number of consecutive transparent pixels that can be encountered "

             "before the giving up search inwards."),

           &m_pixelDistance)

        .SetDefault(m_pixelDistance)

        .SetMinValueIncluded(0);

    AddArg("add-alpha", 0, _("Adds an alpha band to the output dataset."),

           &m_addAlpha)

        .SetMutualExclusionGroup("addalpha-addmask");

    AddArg("add-mask", 0, _("Adds a mask band to the output dataset."),

           &m_addMask)

        .SetMutualExclusionGroup("addalpha-addmask");

    AddArg("algorithm", 0, _("Algorithm to apply"), &m_algorithm)

        .SetChoices("floodfill", "twopasses")

        .SetDefault(m_algorithm);

}

/************************************************************************/

/*              GDALRasterCleanCollarAlgorithm::RunImpl()               */

/************************************************************************/

bool GDALRasterCleanCollarAlgorithm::RunImpl(GDALProgressFunc pfnProgress,

                                             void *pProgressData)

{

    auto poSrcDS = m_inputDataset.GetDatasetRef();

    CPLAssert(poSrcDS);

    auto poDstDS = m_outputDataset.GetDatasetRef();

    if (poSrcDS == poDstDS && poSrcDS->GetAccess() == GA_ReadOnly)

    {

        ReportError(CE_Failure, CPLE_AppDefined,

                    "Dataset should be opened in update mode");

        return false;

    }

    if (!poDstDS && !m_outputDataset.IsNameSet() && m_update)

    {

        m_outputDataset.Set(poSrcDS);

        poDstDS = poSrcDS;

    }

    const bool dstDSWasNull = poDstDS == nullptr;

    if (dstDSWasNull && !m_outputDataset.IsNameSet() && !m_update)

    {

        ReportError(CE_Failure, CPLE_AppDefined,

                    "Output dataset is not specified. If you intend to update "

                    "the input dataset, set the 'update' option");

        return false;

    }

    if (!poDstDS && !m_outputDataset.GetName().empty() && poDstDS != poSrcDS)

    {

        VSIStatBufL sStat;

        bool fileExists{VSIStatL(m_outputDataset.GetName().c_str(), &sStat) ==

                        0};

        {

            CPLErrorStateBackuper oCPLErrorHandlerPusher(CPLQuietErrorHandler);

            poDstDS = GDALDataset::FromHandle(GDALOpenEx(

                m_outputDataset.GetName().c_str(),

                GDAL_OF_RASTER | GDAL_OF_VERBOSE_ERROR | GDAL_OF_UPDATE,

                nullptr, nullptr, nullptr));

            CPLErrorReset();

        }

        if ((poDstDS || fileExists) && !m_overwrite && !m_update)

        {

            CPLError(CE_Failure, CPLE_AppDefined,

                     "Dataset '%s' already exists. Specify the --overwrite "

                     "option to overwrite it or the --update option to "

                     "update it.",

                     m_outputDataset.GetName().c_str());

            delete poDstDS;

            return false;

        }

        if (poDstDS && fileExists && m_overwrite)

        {

            // Delete the existing file

            delete poDstDS;

            poDstDS = nullptr;

            if (VSIUnlink(m_outputDataset.GetName().c_str()) != 0)

            {

                CPLError(CE_Failure, CPLE_AppDefined,

                         "Failed to delete existing dataset '%s'.",

                         m_outputDataset.GetName().c_str());

                return false;

            }

        }

    }

    CPLStringList aosOptions;

    if (!m_format.empty())

    {

        aosOptions.push_back("-of");

        aosOptions.push_back(m_format.c_str());

    }

    for (const auto &co : m_creationOptions)

    {

        aosOptions.push_back("-co");

        aosOptions.push_back(co.c_str());

    }

    for (const auto &color : m_color)

    {

        aosOptions.push_back("-color");

        std::string osColor;

        int nNonAlphaSrcBands = poSrcDS->GetRasterCount();

        if (nNonAlphaSrcBands &&

            poSrcDS->GetRasterBand(nNonAlphaSrcBands)

                    ->GetColorInterpretation() == GCI_AlphaBand)

            --nNonAlphaSrcBands;

        if (color == "white")

        {

            for (int i = 0; i < nNonAlphaSrcBands; ++i)

            {

                if (i > 0)

                    osColor += ',';

                osColor += "255";

            }

        }

        else if (color == "black")

        {

            for (int i = 0; i < nNonAlphaSrcBands; ++i)

            {

                if (i > 0)

                    osColor += ',';

                osColor += "0";

            }

        }

        else

        {

            osColor = color;

        }

        aosOptions.push_back(osColor.c_str());

    }

    aosOptions.push_back("-near");

    aosOptions.push_back(CPLSPrintf("%d", m_colorThreshold));

    aosOptions.push_back("-nb");

    aosOptions.push_back(CPLSPrintf("%d", m_pixelDistance));

    if (m_addAlpha ||

        (!m_addMask && poDstDS == nullptr && poSrcDS->GetRasterCount() > 0 &&

         poSrcDS->GetRasterBand(poSrcDS->GetRasterCount())

                 ->GetColorInterpretation() == GCI_AlphaBand) ||

        (!m_addMask && poDstDS != nullptr && poDstDS->GetRasterCount() > 0 &&

         poDstDS->GetRasterBand(poDstDS->GetRasterCount())

                 ->GetColorInterpretation() == GCI_AlphaBand))

    {

        aosOptions.push_back("-setalpha");

    }

    if (m_addMask ||

        (!m_addAlpha && poDstDS == nullptr && poSrcDS->GetRasterCount() > 0 &&

         poSrcDS->GetRasterBand(1)->GetMaskFlags() == GMF_PER_DATASET) ||

        (!m_addAlpha && poDstDS != nullptr && poDstDS->GetRasterCount() > 0 &&

         poDstDS->GetRasterBand(1)->GetMaskFlags() == GMF_PER_DATASET))

    {

        aosOptions.push_back("-setmask");

    }

    aosOptions.push_back("-alg");

    aosOptions.push_back(m_algorithm.c_str());

    std::unique_ptr<GDALNearblackOptions, decltype(&GDALNearblackOptionsFree)>

        psOptions{GDALNearblackOptionsNew(aosOptions.List(), nullptr),

                  GDALNearblackOptionsFree};

    if (!psOptions)

        return false;

    GDALNearblackOptionsSetProgress(psOptions.get(), pfnProgress,

                                    pProgressData);

    auto poRetDS = GDALDataset::FromHandle(GDALNearblack(

        m_outputDataset.GetName().c_str(), GDALDataset::ToHandle(poDstDS),

        GDALDataset::ToHandle(poSrcDS), psOptions.get(), nullptr));

    if (!poRetDS)

        return false;

    if (poDstDS == nullptr)

    {

        m_outputDataset.Set(std::unique_ptr<GDALDataset>(poRetDS));

    }

    else if (dstDSWasNull)

    {

        const bool bCloseOK = poDstDS->Close() == CE_None;

        delete poDstDS;

        if (!bCloseOK)

        {

            CPLError(CE_Failure, CPLE_AppDefined,

                     "Failed to close output dataset");

            return false;

        }

    }

    return true;

}

//! @endcond