/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache license, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the license for the specific language governing permissions and
 * limitations under the license.
 */
package org.apache.logging.log4j.core.appender.rolling.action;

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileOwnerAttributeView;
import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.List;
import java.util.Set;

import org.apache.logging.log4j.core.Core;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute;
import org.apache.logging.log4j.core.config.plugins.PluginBuilderFactory;
import org.apache.logging.log4j.core.config.plugins.PluginConfiguration;
import org.apache.logging.log4j.core.config.plugins.PluginElement;
import org.apache.logging.log4j.core.config.plugins.validation.constraints.Required;
import org.apache.logging.log4j.core.lookup.StrSubstitutor;
import org.apache.logging.log4j.core.util.FileUtils;
import org.apache.logging.log4j.util.Strings;

/**
 * File posix attribute view action.
 * 
 * Allow to define file permissions, user and group for log files on posix supported OS.
 */
@Plugin(name = "PosixViewAttribute", category = Core.CATEGORY_NAME, printObject = true)
public class PosixViewAttributeAction extends AbstractPathAction {
    
    /**
     * File permissions.
     */
    private final Set<PosixFilePermission> filePermissions;

    /**
     * File owner.
     */
    private final String fileOwner;

    /**
     * File group.
     */
    private final String fileGroup;

    private PosixViewAttributeAction(final String basePath, final boolean followSymbolicLinks,
            final int maxDepth, final PathCondition[] pathConditions, final StrSubstitutor subst,
            final Set<PosixFilePermission> filePermissions,
            final String fileOwner, final String fileGroup) {
        super(basePath, followSymbolicLinks, maxDepth, pathConditions, subst);
        this.filePermissions = filePermissions;
        this.fileOwner = fileOwner;
        this.fileGroup = fileGroup;
    }

    @PluginBuilderFactory
    public static Builder newBuilder() {
        return new Builder();
    }

    /**
     * Builder for the posix view attribute action.
     */
    public static class Builder implements org.apache.logging.log4j.core.util.Builder<PosixViewAttributeAction> {

        @PluginConfiguration
        private Configuration configuration;
        
        private StrSubstitutor subst;

        @PluginBuilderAttribute
        @Required(message = "No base path provided")
        private String basePath;

        @PluginBuilderAttribute
        private boolean followLinks = false;

        @PluginBuilderAttribute
        private int maxDepth = 1;

        @PluginElement("PathConditions")
        private PathCondition[] pathConditions;

        @PluginBuilderAttribute(value = "filePermissions")
        private String filePermissionsString;

        private Set<PosixFilePermission> filePermissions;

        @PluginBuilderAttribute
        private String fileOwner;

        @PluginBuilderAttribute
        private String fileGroup;

        @Override
        public PosixViewAttributeAction build() {
            if (Strings.isEmpty(basePath)) {
                LOGGER.error("Posix file attribute view action not valid because base path is empty.");
                return null;
            }

            if (filePermissions == null && Strings.isEmpty(filePermissionsString)
                        && Strings.isEmpty(fileOwner) && Strings.isEmpty(fileGroup)) {
                LOGGER.error("Posix file attribute view not valid because nor permissions, user or group defined.");
                return null;
            }

            if (!FileUtils.isFilePosixAttributeViewSupported()) {
                LOGGER.warn("Posix file attribute view defined but it is not supported by this files system.");
                return null;
            }

            return new PosixViewAttributeAction(basePath, followLinks, maxDepth, pathConditions,
                    subst != null ? subst : configuration.getStrSubstitutor(),
                    filePermissions != null ? filePermissions :
                                filePermissionsString != null ? PosixFilePermissions.fromString(filePermissionsString) : null,
                    fileOwner,
                    fileGroup);
        }

        /**
         * Define required configuration, used to retrieve string substituter.
         *
         * @param configuration {@link AbstractPathAction#getStrSubstitutor()}
         * @return This builder
         */
        public Builder withConfiguration(final Configuration configuration) {
            this.configuration = configuration;
            return this;
        }

        /**
         * Define string substituter.
         *
         * @param subst {@link AbstractPathAction#getStrSubstitutor()}
         * @return This builder
         */
        public Builder withSubst(final StrSubstitutor subst) {
            this.subst = subst;
            return this;
        }

        /**
         * Define base path to apply condition before execute posix file attribute action.
         * @param basePath {@link AbstractPathAction#getBasePath()}
         * @return This builder
         */
        public Builder withBasePath(final String basePath) {
            this.basePath = basePath;
            return this;
        }

        /**
         * True to allow synonyms links during search of eligible files.
         * @param followLinks Follow synonyms links
         * @return This builder
         */
        public Builder withFollowLinks(final boolean followLinks) {
            this.followLinks = followLinks;
            return this;
        }

        /**
         * Define max folder depth to search for eligible files to apply posix attribute view.
         * @param maxDepth Max search depth 
         * @return This builder
         */
        public Builder withMaxDepth(final int maxDepth) {
            this.maxDepth = maxDepth;
            return this;
        }

        /**
         * Define path conditions to filter files in {@link PosixViewAttributeAction#getBasePath()}.
         *
         * @param pathConditions {@link AbstractPathAction#getPathConditions()}
         * @return This builder
         */
        public Builder withPathConditions(final PathCondition[] pathConditions) {
            this.pathConditions = pathConditions;
            return this;
        }

        /**
         * Define file permissions in posix format to apply during action execution eligible files.
         *
         * Example:
         * <p>rw-rw-rw
         * <p>r--r--r--
         * @param filePermissionsString Permissions to apply
         * @return This builder
         */
        public Builder withFilePermissionsString(final String filePermissionsString) {
            this.filePermissionsString = filePermissionsString;
            return this;
        }

        /**
         * Define file permissions to apply during action execution eligible files.
         * @param filePermissions Permissions to apply
         * @return This builder
         */
        public Builder withFilePermissions(final Set<PosixFilePermission> filePermissions) {
            this.filePermissions = filePermissions;
            return this;
        }

        /**
         * Define file owner to apply during action execution eligible files.
         * @param fileOwner File owner
         * @return This builder
         */
        public Builder withFileOwner(final String fileOwner) {
            this.fileOwner = fileOwner;
            return this;
        }

        /**
         * Define file group to apply during action execution eligible files.
         * @param fileGroup File group
         * @return This builder
         */
        public Builder withFileGroup(final String fileGroup) {
            this.fileGroup = fileGroup;
            return this;
        }
    }

    @Override
    protected FileVisitor<Path> createFileVisitor(final Path basePath,
            final List<PathCondition> conditions) {
        return new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
                for (final PathCondition pathFilter : conditions) {
                    final Path relative = basePath.relativize(file);
                    if (!pathFilter.accept(basePath, relative, attrs)) {
                        LOGGER.trace("Not defining posix attribute base={}, relative={}", basePath, relative);
                        return FileVisitResult.CONTINUE;
                    }
                }
                FileUtils.defineFilePosixAttributeView(file, filePermissions, fileOwner, fileGroup);
                return FileVisitResult.CONTINUE;
            }
        };
    }

    /**
     * Returns posix file permissions if defined and the OS supports posix file attribute,
     * null otherwise.
     * @return File posix permissions
     * @see PosixFileAttributeView
     */
    public Set<PosixFilePermission> getFilePermissions() {
        return filePermissions;
    }
    
    /**
     * Returns file owner if defined and the OS supports owner file attribute view,
     * null otherwise. 
     * @return File owner
     * @see FileOwnerAttributeView
     */
    public String getFileOwner() {
        return fileOwner;
    }

    /**
     * Returns file group if defined and the OS supports posix/group file attribute view,
     * null otherwise. 
     * @return File group
     * @see PosixFileAttributeView
     */
    public String getFileGroup() {
        return fileGroup;
    }

    @Override
    public String toString() {
        return "PosixViewAttributeAction [filePermissions=" + filePermissions + ", fileOwner="
                + fileOwner + ", fileGroup=" + fileGroup + ", getBasePath()=" + getBasePath()
                + ", getMaxDepth()=" + getMaxDepth() + ", getPathConditions()="
                + getPathConditions() + "]";
    }

}
