import org.lastaflute.core.message.UserMessages;
import org.opensearch.index.query.BoolQueryBuilder;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;

/**
 * Query command implementation for handling Boolean queries.
 * Converts Lucene BooleanQuery objects to OpenSearch BoolQueryBuilder objects.
 */
public class BooleanQueryCommand extends QueryCommand {
    /**

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<KeyMatchCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<KeyMatchCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

        boolQueryBuilder.add(termQuery3, BooleanClause.Occur.MUST_NOT);
        BooleanQuery booleanQuery = boolQueryBuilder.build();

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = booleanQueryCommand.convertBooleanQuery(context, booleanQuery, 1.0f);

        assertNotNull(result);
        assertTrue(result instanceof BoolQueryBuilder);

        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;

        assertNotNull(result);
        assertTrue(result instanceof BoolQueryBuilder);
        BoolQueryBuilder boolQueryBuilder = (BoolQueryBuilder) result;
        // BoostQueryCommand doesn't apply boost to BooleanQuery, it's applied within the clauses
        assertEquals(1.0f, boolQueryBuilder.boost());
    }

    @Test
    public void test_execute_withPrefixQuery() {

        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }

    public void bool(BoolCall<ElevateWordToLabelCQ> boolLambda) {
        bool(boolLambda, null);
    }

    public void bool(BoolCall<ElevateWordToLabelCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<RoleCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<RoleCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

     *
     * @param queryBuilder the query builder to wrap (must be BoolQueryBuilder or DisMaxQueryBuilder)
     * @throws IllegalArgumentException if the query builder type is not supported
     */
    public DefaultQueryBuilder(final QueryBuilder queryBuilder) {
        this.queryBuilder = queryBuilder;
        if (queryBuilder instanceof BoolQueryBuilder) {
            queryType = QueryType.BOOL;

        });

        QueryBuilder result = queryContext.getQueryBuilder();
        assertNotNull(result);
        assertTrue(result instanceof BoolQueryBuilder);
        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;
        assertTrue(boolResult.hasClauses());
    }

    // Test addQuery with no clauses added
    @Test
    public void test_addQuery_withNoClauses() {

        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }

    public void bool(BoolCall<ThumbnailQueueCQ> boolLambda) {
        bool(boolLambda, null);
    }

    public void bool(BoolCall<ThumbnailQueueCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {

        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }

    public void bool(BoolCall<FavoriteLogCQ> boolLambda) {
        bool(boolLambda, null);
    }

    public void bool(BoolCall<FavoriteLogCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {