/*
    * SPDX-License-Identifier: Apache-2.0
    * See LICENSE file for details.
    *
    * Copyright 2012-2026 Hazendaz
    */
   package com.github.hazendaz.maven.smartsprites_maven_plugin;
   
   import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.Method;
  import java.util.List;
  
  import javax.xml.parsers.DocumentBuilderFactory;
  
  import org.apache.maven.plugin.MojoExecutionException;
  import org.junit.jupiter.api.Test;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  
  /**
   * The Class HelpMojoTest.
   */
  public class HelpMojoTest {
  
      /**
       * Test execute with default parameters.
       */
      @Test
      void testExecuteWithDefaultParameters() {
          HelpMojo mojo = new HelpMojo();
          assertDoesNotThrow(mojo::execute);
      }
  
      /**
       * Test execute with detail and goal.
       *
       * @throws ReflectiveOperationException
       *             the reflective operation exception
       */
      @Test
      void testExecuteWithDetailAndGoal() throws ReflectiveOperationException {
          HelpMojo mojo = new HelpMojo();
          setField(mojo, "detail", true);
          setField(mojo, "goal", "smartsprites");
          setField(mojo, "lineLength", 64);
          setField(mojo, "indentSize", 2);
  
          assertDoesNotThrow(mojo::execute);
      }
  
      /**
       * Test get single child throws for missing and multiple.
       *
       * @throws Exception
       *             the exception
       */
      @Test
      void testGetSingleChildThrowsForMissingAndMultiple() throws Exception {
          Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
          Element root = document.createElement("root");
          document.appendChild(root);
          root.appendChild(document.createElement("a"));
          root.appendChild(document.createElement("a"));
  
          Method getSingleChild = method("getSingleChild", Node.class, String.class);
          assertThrows(MojoExecutionException.class, () -> invoke(getSingleChild, null, root, "missing"));
          assertThrows(MojoExecutionException.class, () -> invoke(getSingleChild, null, root, "a"));
      }
  
      /**
       * Test find single child returns null when missing.
       *
       * @throws Exception
       *             the exception
       */
      @Test
      void testFindSingleChildReturnsNullWhenMissing() throws Exception {
          Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
          Element root = document.createElement("root");
          document.appendChild(root);
  
          Method findSingleChild = method("findSingleChild", Node.class, String.class);
          Object child = invoke(findSingleChild, null, root, "absent");
  
          assertNull(child);
      }
  
      /**
       * Test get property from expression variants.
       *
       * @throws Exception
       *             the exception
      */
     @Test
     void testGetPropertyFromExpressionVariants() throws Exception {
         Method method = method("getPropertyFromExpression", String.class);
         assertEquals("demo.property", invoke(method, null, "${demo.property}"));
         assertNull(invoke(method, null, "${a${b}}"));
         assertNull(invoke(method, null, "plain-value"));
     }
 
     /**
      * Test to lines wraps and normalizes whitespace.
      *
      * @throws Exception
      *             the exception
      */
     @Test
     @SuppressWarnings("unchecked")
     void testToLinesWrapsAndNormalizesWhitespace() throws Exception {
         Method toLines = method("toLines", String.class, int.class, int.class, int.class);
         List<String> lines = (List<String>) invoke(toLines, null, "\tword\u00A0word longlongtoken", 1, 2, 12);
 
         assertTrue(lines.size() > 1);
         assertTrue(lines.stream().noneMatch(line -> line.contains("\u00A0")));
     }
 
     /**
      * Method.
      *
      * @param name
      *            the name
      * @param parameterTypes
      *            the parameter types
      *
      * @return the method
      *
      * @throws ReflectiveOperationException
      *             the reflective operation exception
      */
     private static Method method(String name, Class<?>... parameterTypes) throws ReflectiveOperationException {
         Method method = HelpMojo.class.getDeclaredMethod(name, parameterTypes);
         method.setAccessible(true);
         return method;
     }
 
     /**
      * Invoke.
      *
      * @param method
      *            the method
      * @param target
      *            the target
      * @param args
      *            the args
      *
      * @return the object
      *
      * @throws Exception
      *             the exception
      */
     private static Object invoke(Method method, Object target, Object... args) throws Exception {
         try {
             return method.invoke(target, args);
         } catch (ReflectiveOperationException e) {
             if (e.getCause() instanceof Exception) {
                 throw (Exception) e.getCause();
             }
             throw e;
         }
     }
 
     /**
      * Set field.
      *
      * @param target
      *            the target
      * @param fieldName
      *            the field name
      * @param value
      *            the value
      *
      * @throws ReflectiveOperationException
      *             the reflective operation exception
      */
     private static void setField(Object target, String fieldName, Object value) throws ReflectiveOperationException {
         Field field = target.getClass().getDeclaredField(fieldName);
         field.setAccessible(true);
         field.set(target, value);
     }
 }