/*
 *  Copyright 2019 Anyware Services
 *
 *  Licensed 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.ametys.plugins.core.impl.group.directory;

import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang3.StringUtils;

import org.ametys.core.group.Group;
import org.ametys.core.group.GroupIdentity;
import org.ametys.core.group.directory.GroupDirectory;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.SizeUtils.ExcludeFromSizeCalculation;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
/**
 * Static implementation of a {@link GroupDirectory}
 */
public class StaticGroupDirectory extends AbstractLogEnabled implements GroupDirectory
{
    private static final String __PARAMETER_GROUPS_DEFINITION = "runtime.groups.static.group";
    
    private String _id;
    private I18nizableText _label;
    private String _gdModelId;
    private Map<String, Object> _params;

    private Map<String, Group> _groups;
    
    @Override
    public String getId()
    {
        return _id;
    }

    @Override
    public I18nizableText getLabel()
    {
        return _label;
    }

    @Override
    public void setId(String id)
    {
        _id = id;
    }

    @Override
    public void setLabel(I18nizableText label)
    {
        _label = label;
    }

    @Override
    public String getGroupDirectoryModelId()
    {
        return _gdModelId;
    }

    @Override
    public Map<String, Object> getParameterValues()
    {
        return _params;
    }

    @Override
    public void init(String groupDirectoryModelId, Map<String, Object> paramValues) throws Exception
    {
        _gdModelId = groupDirectoryModelId;
        _groups = new HashMap<>();
        _params = paramValues;
        String groupsAsText = (String) paramValues.get(__PARAMETER_GROUPS_DEFINITION);
        for (String groupLine : groupsAsText.split("\\n"))
        {
            if (StringUtils.isNotEmpty(groupLine))
            {
                String[] groupSplited = groupLine.split(":");
                if (groupSplited.length == 0)
                {
                    getLogger().error("Error while reading StaticGroupDirectory groups, cannot create a group with the data from line {}", groupLine);
                }
                else
                {
                    String groupId = groupSplited[0];
                    String label = groupSplited[groupSplited.length > 1 ? 1 : 0];
                    Set<UserIdentity> users = new HashSet<>();
                    for (int i = 2; i < groupSplited.length; i++)
                    {
                        String userLogin = groupSplited[i].indexOf("#") > -1 ? StringUtils.substringBefore(groupSplited[i], "#") : groupSplited[i];
                        String userPopulation = groupSplited[i].indexOf("#") > -1 ? StringUtils.substringAfter(groupSplited[i], "#") : null;
                        users.add(new UserIdentity(userLogin, userPopulation));
                    }
                    _groups.put(groupId, new StaticGroup(groupId, _id, label, this, users));
                }
            }
        }
        
    }

    @Override
    public Group getGroup(String groupID)
    {
        return _groups.getOrDefault(groupID, null);
    }

    @Override
    public Set<Group> getGroups()
    {
        return new HashSet<>(_groups.values());
    }

    @Override
    public Set<String> getUserGroups(UserIdentity userIdentity)
    {
        return _groups.values().stream()
                .filter(group -> group.getUsers().contains(userIdentity))
                .map(Group::getIdentity)
                .map(GroupIdentity::getId)
                .collect(Collectors.toSet());
    }

    @Override
    public List<Group> getGroups(int count, int offset, Map parameters)
    {
        String pattern = (String) parameters.get("pattern");
        boolean sort = (boolean) parameters.getOrDefault("sort", false);
        Predicate<Group> matchesPattern = group ->
            StringUtils.isEmpty(pattern) 
                || group.getLabel().toLowerCase().indexOf(pattern.toLowerCase()) != -1 
                || group.getIdentity() != null && group.getIdentity().getId().toLowerCase().indexOf(pattern.toLowerCase()) != -1;
            
        Stream<Group> groupsStream = _groups.values().stream()
                .filter(matchesPattern);
        if (sort)
        {
            groupsStream = groupsStream.sorted(Comparator.comparing(Group::getLabel, String.CASE_INSENSITIVE_ORDER));
        }
        return groupsStream
                .skip(offset)
                .limit(count)
                .collect(Collectors.toList());
    }

    private static final class StaticGroup implements Group
    {
        private GroupIdentity _identity;
        private String _label;
        private Set<UserIdentity> _users;

        @ExcludeFromSizeCalculation
        private GroupDirectory _groupDirectory;
        
        StaticGroup(String id, String directoryId, String label, GroupDirectory groupDirectory, Set<UserIdentity> users)
        {
            _identity = new GroupIdentity(id, directoryId);
            _label = label;
            _groupDirectory = groupDirectory;
            _users = users;
        }
        
        public GroupIdentity getIdentity()
        {
            return _identity;
        }

        public String getLabel()
        {
            return _label;
        }

        public GroupDirectory getGroupDirectory()
        {
            return _groupDirectory;
        }

        public Set<UserIdentity> getUsers()
        {
            return _users;
        }
        
    }
}