package org.geoserver.security.filter;

import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.geoserver.security.GeoServerSecurityFilterChain;
import org.geoserver.security.config.SecurityNamedServiceConfig;
import org.geoserver.security.config.UsernamePasswordAuthenticationFilterConfig;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint;
import org.springframework.security.web.authentication.RememberMeServices;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.session.ChangeSessionIdAuthenticationStrategy;
import org.springframework.security.web.authentication.session.SessionFixationProtectionStrategy;

/**
 * User name / password authentication filter
 * 
 * 核心功能：处理基于表单的用户名/密码认证流程
 * 1. 拦截登录请求
 * 2. 提取用户名/密码
 * 3. 执行认证逻辑
 * 4. 处理认证结果（成功/失败）
 * 5. 提供认证入口点
 *
 * @author christian
 */
public class GeoServerUserNamePasswordAuthenticationFilter extends GeoServerCompositeFilter
        implements GeoServerAuthenticationFilter {

    // 登录处理相关URL常量
    public static final String URL_LOGIN_SUCCCESS = "/web";  // 登录成功后的默认重定向地址
    public static final String URL_LOGIN_FAILURE =  // 登录失败重定向地址（带错误参数）
            "/web/wicket/bookmarkable/org.geoserver.web.GeoServerLoginPage?error=true";
    public static final String URL_LOGIN_FORM =     // 登录表单地址（无错误状态）
            "/web/wicket/bookmarkable/org.geoserver.web.GeoServerLoginPage?error=false";

    private LoginUrlAuthenticationEntryPoint aep;  // 认证入口点（处理未认证请求）
    String[] pathInfos;  // 需要启用认证的路径模式

    /**
     * 从配置初始化过滤器
     * 核心配置方法：创建并配置Spring Security的认证过滤器链
     */
    @Override
    public void initializeFromConfig(SecurityNamedServiceConfig config) throws IOException {
        super.initializeFromConfig(config);

        // 获取需要认证的路径列表（逗号分隔）
        pathInfos = GeoServerSecurityFilterChain.FORM_LOGIN_CHAIN.split(",");

        // 转换为用户名密码过滤器的专用配置
        UsernamePasswordAuthenticationFilterConfig upConfig = 
            (UsernamePasswordAuthenticationFilterConfig) config;

        // 1. 配置认证入口点（当访问受保护资源时跳转到登录页）
        aep = new LoginUrlAuthenticationEntryPoint(URL_LOGIN_FORM);
        aep.setForceHttps(false);  // 不强制HTTPS（生产环境应设为true）
        try {
            aep.afterPropertiesSet();  // Spring标准初始化方法
        } catch (Exception e2) {
            throw new IOException(e2);
        }

        // 2. 获取RememberMe服务（实现"记住我"功能）
        RememberMeServices rms = securityManager.getRememberMeService();

        // 3. 创建Spring Security的用户名密码认证过滤器
        UsernamePasswordAuthenticationFilter filter = new UsernamePasswordAuthenticationFilter() {
            /**
             * 重写认证请求判断逻辑
             * 只对特定路径的请求启用认证处理
             */
            @Override
            protected boolean requiresAuthentication(
                HttpServletRequest request, HttpServletResponse response) {
                
                // 检查当前请求路径是否在需要认证的路径列表中
                for (String pathInfo : pathInfos) {
                    if (getRequestPath(request).startsWith(pathInfo)) 
                        return true;
                }
                return false;
            }
        };

        // 4. 配置过滤器的基本参数
        filter.setPasswordParameter(upConfig.getPasswordParameterName());  // 密码参数名（默认"password"）
        filter.setUsernameParameter(upConfig.getUsernameParameterName());  // 用户名参数名（默认"username"）
        filter.setAuthenticationManager(getSecurityManager().authenticationManager()); // 设置认证管理器
        
        // 5. 配置附加服务
        filter.setRememberMeServices(rms);  // 集成RememberMe功能
        GeoServerWebAuthenticationDetailsSource s = new GeoServerWebAuthenticationDetailsSource();
        filter.setAuthenticationDetailsSource(s);  // 自定义认证详情源（获取IP等信息）

        // 6. 会话固定攻击防护
        try {
            // Servlet 3.1+ 使用会话ID变更策略（更安全）
            filter.setSessionAuthenticationStrategy(new ChangeSessionIdAuthenticationStrategy());
        } catch (IllegalStateException e) {
            // 旧版Servlet使用会话迁移策略
            filter.setSessionAuthenticationStrategy(new SessionFixationProtectionStrategy());
        }
        filter.setAllowSessionCreation(false);  // 禁止随意创建会话

        // 7. 配置认证结果处理器
        // 7.1 认证成功处理器
        SimpleUrlAuthenticationSuccessHandler successHandler = 
            new SimpleUrlAuthenticationSuccessHandler();
        successHandler.setDefaultTargetUrl(URL_LOGIN_SUCCCESS);  // 登录成功重定向到主页
        filter.setAuthenticationSuccessHandler(successHandler);
        
        // 7.2 认证失败处理器
        SimpleUrlAuthenticationFailureHandler failureHandler = 
            new SimpleUrlAuthenticationFailureHandler();
        failureHandler.setDefaultFailureUrl(URL_LOGIN_FAILURE);  // 登录失败重定向回登录页（带错误标记）
        filter.setAuthenticationFailureHandler(failureHandler);

        // 8. 将配置好的过滤器添加到嵌套过滤器链
        getNestedFilters().add(filter);
    }

    /**
     * 获取认证入口点
     * 当用户访问受保护资源时，此入口点负责引导到登录页
     */
    @Override
    public AuthenticationEntryPoint getAuthenticationEntryPoint() {
        return aep;
    }

    /**
     * 过滤器核心执行方法
     * 将认证入口点存入请求属性，供后续流程使用
     */
    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        // 在请求中存储认证入口点引用
        req.setAttribute(GeoServerSecurityFilter.AUTHENTICATION_ENTRY_POINT_HEADER, aep);
        // 继续执行过滤器链
        super.doFilter(req, res, chain);
    }

    /** 标识此过滤器适用于HTML界面 */
    @Override
    public boolean applicableForHtml() {
        return true;  // 处理Web界面认证
    }

    /** 标识此过滤器不适用于服务端点 */
    @Override
    public boolean applicableForServices() {
        return false;  // 不处理WFS/WMS等OGC服务认证
    }
}

private void handleOnSubmit() {
    // Catalog 是 GeoServer 中管理所有数据（如工作区、命名空间等）的核心类。通过 getCatalog() 获取当前的目录实例，后续操作都依赖它。
    Catalog catalog = getCatalog();
    // 获取用户输入的工作区信息。model 是一个封装了用户表单数据的模型对象（CompoundPropertyModel<WorkspaceInfo>）。调用 getObject() 获取用户填写的工作区信息（如名称等）。
    WorkspaceInfo workspace = model.getObject();
    // 创建并设置命名空间信息 命名空间前缀（Prefix）使用工作区名称 命名空间 URI 从页面输入框中获取 是否隔离（Isolated）与工作区保持一致
    NamespaceInfo namespace = catalog.getFactory().createNamespace();
    namespace.setPrefix(workspace.getName());
    namespace.setURI(nsUriTextField.getDefaultModelObjectAsString());
    namespace.setIsolated(workspace.isIsolated());
    // 验证工作区和命名空间是否合法
    // 调用 catalog.validate(...) 检查工作区和命名空间是否符合规范（如名称是否合法、是否重复等）。使用 validateAndReport(...) 包装验证逻辑，自动显示错误提示。如果任一验证失败，终止流程并返回错误信息。
    /* validateAndReport(...) 方法说明：
    接收一个函数式参数（验证逻辑），执行校验。
    如果验证失败，记录日志并提示错误。
    返回布尔值表示验证是否通过。*/
    if (!validateAndReport(() -> catalog.validate(workspace, true))
            || !validateAndReport(() -> catalog.validate(namespace, true))) {
        // at least one validation fail
        return;
    }
    // 保存工作区和命名空间若添加过程中发生异常（例如数据库写入失败），调用 cleanAndReport(...) 清理已保存的数据以保证一致性。
    /*cleanAndReport(...) 方法说明：
    判断是否只保存了工作区而未保存命名空间。
    如果是，则删除已保存的工作区，确保两者要么都存在，要么都不存在。
    记录异常信息并提示用户。*/
    try {
        catalog.add(workspace);
        catalog.add(namespace);
    } catch (Exception exception) {
        LOGGER.log(Level.INFO, "Error storing workspace related objects.", exception);
        cleanAndReport(exception);
    }
    // 设置默认工作区（如果勾选） 如果用户勾选了“设为默认工作区”，则更新目录中的默认工作区配置。
    if (infoPanel.defaultWs) {
        catalog.setDefaultWorkspace(workspace);
    }
    //如果用户有权限并且打开了“Security”选项卡，调用 accessdataPanel.save() 保存访问控制规则。成功后跳转回工作区管理页面。如果保存失败，记录日志并提示错误信息。
    try {
        if (accessdataPanel != null) accessdataPanel.save();
        doReturn(WorkspacePage.class);
    } catch (IOException e) {
        LOGGER.log(Level.INFO, "Error saving access rules associated to workspace " + workspace.getName(), e);
        error(e.getMessage() == null ? e.toString() : e.getMessage());
    }
}

@Override
public void add(WorkspaceInfo workspace) {
    //确保workspace对象不为null
    workspace = resolve(workspace);
    //校验workspace
    validate(workspace, true);
    // 检查是否已存在同名工作区
    if (getWorkspaceByName(workspace.getName()) != null) {
        throw new IllegalArgumentException("Workspace with name '" + workspace.getName() + "' already exists.");
    }
    // 调用 beforeadded(workspace) 方法，通知监听器即将添加一个工作区。
    beforeadded(workspace);
    // 获取当前默认工作区
    WorkspaceInfo defaultWorkspace = getDefaultWorkspace();
    WorkspaceInfo added;
        /*如果当前没有默认工作区：
    使用 synchronized 锁定 facade 对象，确保线程安全。
    调用 facade.add(workspace) 将工作区添加进目录。
    如果添加后仍然没有默认工作区，就将当前添加的工作区设为默认工作区：setDefaultWorkspace(workspace)
    如果已有默认工作区：
    直接调用 facade.add(workspace) 添加新工作区即可。*/
    if (defaultWorkspace == null) {
        synchronized (facade) {
            added = facade.add(workspace);
            // if there is no default workspace use this one as the default
            if (getDefaultWorkspace() == null) {
                setDefaultWorkspace(workspace);
            }
        }
    } else {
        added = facade.add(workspace);
    }
    added(added);
}

public T add(T value) {
    //判断传入的 value 是否是一个 Java 动态代理对象（例如由 ModificationProxy.create(...) 创建的代理）。如果是，则通过反射获取其内部封装的真实对象（避免多次代理嵌套导致问题）。
    if (Proxy.isProxyClass(value.getClass())) {
        ModificationProxy h = (ModificationProxy) Proxy.getInvocationHandler(value);
        value = (T) h.getProxyObject();
    }
    // 获取名称映射表（nameMap）
    Map<Name, T> nameMap = getMapForValue(nameMultiMap, value);
    // 生成对象名称（Name）
    Name name = nameMapper.apply(value);
    // 获取 ID 映射表（idMap）
    Map<String, T> idMap = getMapForValue(idMultiMap, value);
    // 加锁写入数据（线程安全）
    writeLock.lock();
    try {
        nameMap.put(name, value);
        return idMap.put(value.getId(), value);
    } finally {
        writeLock.unlock();
    }
}

public void add(NamespaceInfo namespace) {
    // 验证命名空间信息的有效性
    validate(namespace, true);

    NamespaceInfo added;
    // 解析命名空间信息，以处理可能的命名空间冲突或重复
    final NamespaceInfo resolved = resolve(namespace);
    // 在添加命名空间之前执行的预处理步骤
    beforeadded(namespace);

    // 获取当前的默认命名空间
    NamespaceInfo defaultNamespace = getDefaultNamespace();
    if (defaultNamespace == null) {
        // 如果当前没有默认命名空间，同步添加过程以避免并发问题
        synchronized (facade) {
            // 添加解析后的命名空间
            added = facade.add(resolved);
            // 如果系统中仍然没有默认命名空间，将新添加的命名空间设置为默认
            if (getDefaultNamespace() == null) {
                setDefaultNamespace(resolved);
            }
        }
    } else {
        // 如果已有默认命名空间，直接添加解析后的命名空间
        added = facade.add(resolved);
    }
    // 添加完成后执行的后处理步骤
    added(added);
}

public NamespaceInfo add(NamespaceInfo value) {
    writeLock.lock();
    try {
        // 调用public T add(T value) 将传入的 NamespaceInfo 添加到其内部存储结构中
        NamespaceInfo ns = super.add(value);
        // 此方法用于更新当前类维护的 ConcurrentHashMap<String, List<NamespaceInfo>> index 索引。它会根据 NamespaceInfo 的 URI 将其加入对应的列表中，并保持列表按 ID 排序。
        addInternal(value);
        return ns;
    } finally {
        writeLock.unlock();
    }
}

protected void onStyleFormSubmit() {
    // 获取目录和模型对象
    Catalog catalog = getCatalog();
    StyleInfo model = styleForm.getModelObject();
    // 使用目录工厂创建一个全新的 StyleInfo 对象，并通过 CatalogBuilder 把表单数据复制进去。
    StyleInfo s = catalog.getFactory().createStyle();
    CatalogBuilder builder = new CatalogBuilder(catalog);
    builder.updateStyle(s, model);

    StyleHandler styleHandler = styleHandler();

    // 写入 SLD 文件如果图例为空或没有在线资源地址，则将图例设为 null
    if (null == s.getLegend()
            || null == s.getLegend().getOnlineResource()
            || s.getLegend().getOnlineResource().isEmpty()) {
        s.setLegend(null);
    }

    // 写入 SLD 文件，如果文件名为空，则根据样式名称生成文件名（如 mystyle.sld），然后把用户输入的原始样式内容（rawStyle）写入资源池中。
    try {
        if (s.getFilename() == null) {
            // TODO: check that this does not override any existing files
            s.setFilename(s.getName() + "." + styleHandler.getFileExtension());
        }
        catalog.getResourcePool().writeStyle(s, new ByteArrayInputStream(rawStyle.getBytes()));
    } catch (IOException e) {
        throw new WicketRuntimeException(e);
    }

    // 获取样式版本号，设置格式版本，然后调用 catalog.add(s) 将样式正式添加进目录。成功后提示“Style saved”。
    try {
        Version version = styleHandler.version(rawStyle);
        s.setFormatVersion(version);
        catalog.add(s);
        styleForm.info("Style saved");

    } catch (Exception e) {
        LOGGER.log(Level.SEVERE, "Error occurred saving the style", e);
        error(e.getMessage());
    }
}

@Override
protected ModelAndView handleRequestInternal(HttpServletRequest httpRequest, HttpServletResponse httpResponse)
        throws Exception {
    // 对 HTTP 请求进行预处理，括设置编码
    preprocessRequest(httpRequest);

    // 初始化一个自定义的 Request 对象，用于封装整个请求过程中的上下文信息。
    Request request = new Request();

    // 将原始的 HTTP 请求和响应对象保存进 Request 中，便于后续使用。
    request.setHttpRequest(httpRequest);
    request.setHttpResponse(httpResponse);

    Service service = null;

    try {
        // 调用 init() 方法对请求进行进一步初始化
        /* 该函数 init 的主要功能是初始化一个 OWS 请求对象（Request），根据 HTTP 请求的方法和内容类型解析请求参数、处理不同类型的请求体（如 SOAP、multipart/form-data、XML POST），并设置相关字段以供后续处理使用。*/  
        request = init(request);

        // 使用 ThreadLocal 存储当前线程的请求上下文，避免多线程间冲突。
        REQUEST.set(request);

        // 根据请求参数查找对应的 Service 实现类（如 WMS/WFS/WCS 等）。如果找不到服务或出错，会触发异常处理逻辑。
        try {
            service = service(request);
        } catch (Throwable t) {
            exception(t, null, request);

            return null;
        }

        // 如果在初始化阶段就已经出现错误，直接抛出不再继续执行。
        if (request.getError() != null) {
            throw request.getError();
        }

        // 根据请求内容（如 GetFeature, GetMap）确定要执行的操作，并创建 Operation 对象。
        Operation operation = dispatch(request, service);
        request.setOperation(operation);
        // 如果是 SOAP 请求，做一些特殊标记或处理。
        if (request.isSOAP()) {
            flagAsSOAP(operation);
        }

        // 调用具体服务的操作处理器，执行业务逻辑（如查询数据库、生成 GML 数据等）。
        Object result = execute(request, operation);

        // 如果有返回结果，构建响应内容并写入 HTTP 响应流中。
        if (result != null) {
            response(result, request, operation);
        }
    } catch (Throwable t) {
        // 捕获所有异常，如果是安全相关的异常（如权限不足），重新抛出以便上层处理；否则调用 exception() 方法统一处理错误。
        if (isSecurityException(t)) throw (Exception) t;
        exception(t, service, request);
    } finally {
        // 触发完成后的回调（如日志记录、清理临时文件等）。移除线程局部变量中的请求对象，防止内存泄漏。
        fireFinishedCallback(request);
        REQUEST.remove();
    }

    return null;
}