///////////////////////////////////////////////////////////////////////////////////////////////
// checkstyle: Checks Java source code and other text files for adherence to a set of rules.
// Copyright (C) 2001-2026 the original author or authors.
//
// 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; either
// version 2.1 of the License, or (at your option) any later version.
//
// 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
///////////////////////////////////////////////////////////////////////////////////////////////

package com.puppycrawl.tools.checkstyle.checks.header;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.Reader;
import java.io.StringReader;
import java.net.URI;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

import com.puppycrawl.tools.checkstyle.PropertyType;
import com.puppycrawl.tools.checkstyle.XdocsPropertyType;
import com.puppycrawl.tools.checkstyle.api.AbstractFileSetCheck;
import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
import com.puppycrawl.tools.checkstyle.api.ExternalResourceHolder;
import com.puppycrawl.tools.checkstyle.utils.CommonUtil;

/**
 * Abstract super class for header checks.
 * Provides support for header and headerFile properties.
 */
public abstract class AbstractHeaderCheck extends AbstractFileSetCheck
    implements ExternalResourceHolder {

    /** Pattern to detect occurrences of '\n' in text. */
    private static final Pattern ESCAPED_LINE_FEED_PATTERN = Pattern.compile("\\\\n");

    /** The lines of the header file. */
    private final List<String> readerLines = new ArrayList<>();

    /** Specify the name of the file containing the required header. */
    private URI headerFile;

    /** Specify the character encoding to use when reading the headerFile. */
    @XdocsPropertyType(PropertyType.STRING)
    private Charset charset;

    /**
     * Creates a new {@code AbstractHeaderCheck} instance.
     */
    protected AbstractHeaderCheck() {
        // no code by default
    }

    /**
     * Hook method for post-processing header lines.
     * This implementation does nothing.
     */
    protected abstract void postProcessHeaderLines();

    /**
     * Return the header lines to check against.
     *
     * @return the header lines to check against.
     */
    protected List<String> getHeaderLines() {
        return List.copyOf(readerLines);
    }

    /**
     * Setter to specify the character encoding to use when reading the headerFile.
     *
     * @param charset the charset name to use for loading the header from a file
     */
    public void setCharset(String charset) {
        this.charset = createCharset(charset);
    }

    /**
     * Setter to specify the name of the file containing the required header.
     *
     * @param uri the uri of the header to load.
     * @throws CheckstyleException if fileName is empty.
     */
    public void setHeaderFile(URI uri) throws CheckstyleException {
        if (uri == null) {
            throw new CheckstyleException(
                "property 'headerFile' is missing or invalid in module "
                    + getConfiguration().getName());
        }

        headerFile = uri;
    }

    /**
     * Load the header from a file.
     *
     * @throws CheckstyleException if the file cannot be loaded
     */
    private void loadHeaderFile() throws CheckstyleException {
        checkHeaderNotInitialized();
        try (Reader headerReader = new InputStreamReader(new BufferedInputStream(
                    headerFile.toURL().openStream()), charset)) {
            loadHeader(headerReader);
        }
        catch (final IOException exc) {
            throw new CheckstyleException(
                    "unable to load header file " + headerFile, exc);
        }
    }

    /**
     * Called before initializing the header.
     *
     * @throws IllegalArgumentException if header has already been set
     */
    private void checkHeaderNotInitialized() {
        if (!readerLines.isEmpty()) {
            throw new IllegalArgumentException(
                    "header has already been set - "
                    + "set either header or headerFile, not both");
        }
    }

    /**
     * Creates charset by name.
     *
     * @param name charset name
     * @return created charset
     * @throws UnsupportedCharsetException if charset is unsupported
     */
    private static Charset createCharset(String name) {
        if (!Charset.isSupported(name)) {
            final String message = "unsupported charset: '" + name + "'";
            throw new UnsupportedCharsetException(message);
        }
        return Charset.forName(name);
    }

    /**
     * Specify the required header specified inline.
     * Individual header lines must be separated by the string
     * {@code "\n"}(even on platforms with a different line separator).
     *
     * @param header header content to check against.
     * @throws IllegalArgumentException if the header cannot be interpreted
     */
    public void setHeader(String header) {
        if (!CommonUtil.isBlank(header)) {
            checkHeaderNotInitialized();

            final String headerExpandedNewLines = ESCAPED_LINE_FEED_PATTERN
                    .matcher(header).replaceAll("\n");

            try (Reader headerReader = new StringReader(headerExpandedNewLines)) {
                loadHeader(headerReader);
            }
            catch (final IOException exc) {
                throw new IllegalArgumentException("unable to load header", exc);
            }
        }
    }

    /**
     * Load header to check against from a Reader into readerLines.
     *
     * @param headerReader delivers the header to check against
     * @throws IOException if
     */
    private void loadHeader(final Reader headerReader) throws IOException {
        try (LineNumberReader lnr = new LineNumberReader(headerReader)) {
            String line;
            do {
                line = lnr.readLine();
                if (line != null) {
                    readerLines.add(line);
                }
            } while (line != null);
            postProcessHeaderLines();
        }
    }

    @Override
    protected final void finishLocalSetup() throws CheckstyleException {
        if (headerFile != null) {
            loadHeaderFile();
        }
    }

    @Override
    public Set<String> getExternalResourceLocations() {
        final Set<String> result;

        if (headerFile == null) {
            result = Set.of();
        }
        else {
            result = Set.of(headerFile.toASCIIString());
        }

        return result;
    }

}