/*
 * Copyright DataStax, Inc.
 *
 * 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 com.datastax.oss.driver.mapper;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowable;

import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.BoundStatementBuilder;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import com.datastax.oss.driver.api.core.cql.SimpleStatement;
import com.datastax.oss.driver.api.core.data.GettableByName;
import com.datastax.oss.driver.api.core.data.UdtValue;
import com.datastax.oss.driver.api.core.type.UserDefinedType;
import com.datastax.oss.driver.api.mapper.annotations.Dao;
import com.datastax.oss.driver.api.mapper.annotations.DaoFactory;
import com.datastax.oss.driver.api.mapper.annotations.DaoKeyspace;
import com.datastax.oss.driver.api.mapper.annotations.Mapper;
import com.datastax.oss.driver.api.mapper.annotations.SetEntity;
import com.datastax.oss.driver.api.mapper.entity.saving.NullSavingStrategy;
import com.datastax.oss.driver.api.testinfra.ccm.CcmRule;
import com.datastax.oss.driver.api.testinfra.session.SessionRule;
import com.datastax.oss.driver.categories.ParallelizableTests;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.rules.RuleChain;
import org.junit.rules.TestRule;

@Category(ParallelizableTests.class)
public class SetEntityIT extends InventoryITBase {

  private static final CcmRule CCM_RULE = CcmRule.getInstance();
  private static final SessionRule<CqlSession> SESSION_RULE = SessionRule.builder(CCM_RULE).build();

  @ClassRule
  public static final TestRule CHAIN = RuleChain.outerRule(CCM_RULE).around(SESSION_RULE);

  private static ProductDao dao;
  private static UserDefinedType dimensions2d;

  @BeforeClass
  public static void setup() {
    CqlSession session = SESSION_RULE.session();

    for (String query : createStatements(CCM_RULE)) {
      session.execute(
          SimpleStatement.builder(query).setExecutionProfile(SESSION_RULE.slowProfile()).build());
    }

    InventoryMapper inventoryMapper = new SetEntityIT_InventoryMapperBuilder(session).build();
    dao = inventoryMapper.productDao(SESSION_RULE.keyspace());
    dimensions2d =
        session
            .getKeyspace()
            .flatMap(ks -> session.getMetadata().getKeyspace(ks))
            .flatMap(ks -> ks.getUserDefinedType("dimensions2d"))
            .orElseThrow(AssertionError::new);
  }

  @Test
  public void should_set_entity_on_bound_statement() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement preparedStatement =
        session.prepare("INSERT INTO product (id, description, dimensions) VALUES (?, ?, ?)");
    BoundStatement boundStatement = preparedStatement.bind();

    boundStatement = dao.set(FLAMETHROWER, boundStatement);

    assertMatches(boundStatement, FLAMETHROWER);
  }

  @Test
  public void should_set_entity_on_bound_statement_builder() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement preparedStatement =
        session.prepare("INSERT INTO product (id, description, dimensions) VALUES (?, ?, ?)");
    BoundStatementBuilder builder = preparedStatement.boundStatementBuilder();

    dao.set(builder, FLAMETHROWER);
    BoundStatement boundStatement = builder.build();

    assertMatches(boundStatement, FLAMETHROWER);
  }

  @Test
  public void should_set_entity_on_bound_statement_setting_null() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement preparedStatement =
        session.prepare("INSERT INTO product (id, description, dimensions) VALUES (?, ?, ?)");
    BoundStatementBuilder builder = preparedStatement.boundStatementBuilder();

    dao.setNullFields(
        builder, new Product(FLAMETHROWER.getId(), null, FLAMETHROWER.getDimensions()));
    BoundStatement boundStatement = builder.build();

    assertMatches(
        boundStatement, new Product(FLAMETHROWER.getId(), null, FLAMETHROWER.getDimensions()));
  }

  @Test
  public void should_set_entity_on_bound_statement_without_setting_null() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement preparedStatement =
        session.prepare("INSERT INTO product (id, description, dimensions) VALUES (?, ?, ?)");
    BoundStatementBuilder builder = preparedStatement.boundStatementBuilder();

    dao.setDoNotSetNullFields(
        builder, new Product(FLAMETHROWER.getId(), null, FLAMETHROWER.getDimensions()));
    BoundStatement boundStatement = builder.build();

    // "" is in description because it was not set
    assertMatches(
        boundStatement, new Product(FLAMETHROWER.getId(), "", FLAMETHROWER.getDimensions()));
  }

  @Test
  public void should_set_entity_on_udt_value() {
    CqlSession session = SESSION_RULE.session();
    UserDefinedType udtType =
        session
            .getMetadata()
            .getKeyspace(SESSION_RULE.keyspace())
            .orElseThrow(AssertionError::new)
            .getUserDefinedType("dimensions")
            .orElseThrow(AssertionError::new);
    UdtValue udtValue = udtType.newValue();
    Dimensions dimensions = new Dimensions(30, 10, 8);

    dao.set(dimensions, udtValue);

    assertThat(udtValue.getInt("length")).isEqualTo(dimensions.getLength());
    assertThat(udtValue.getInt("width")).isEqualTo(dimensions.getWidth());
    assertThat(udtValue.getInt("height")).isEqualTo(dimensions.getHeight());
  }

  @Test
  public void should_set_entity_on_partial_statement_when_lenient() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement ps = session.prepare("INSERT INTO product (id, description) VALUES (?, ?)");
    BoundStatement bound = dao.setLenient(FLAMETHROWER, ps.bind());
    assertThat(bound.getUuid(0)).isEqualTo(FLAMETHROWER.getId());
    assertThat(bound.getString(1)).isEqualTo(FLAMETHROWER.getDescription());
  }

  @Test
  public void should_set_entity_on_partial_statement_builder_when_lenient() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement ps = session.prepare("INSERT INTO product (id, description) VALUES (?, ?)");
    BoundStatementBuilder builder = ps.boundStatementBuilder();
    dao.setLenient(FLAMETHROWER, builder);
    assertThat(builder.getUuid(0)).isEqualTo(FLAMETHROWER.getId());
    assertThat(builder.getString(1)).isEqualTo(FLAMETHROWER.getDescription());
  }

  @Test
  @SuppressWarnings("ResultOfMethodCallIgnored")
  public void should_set_entity_on_partial_udt_when_lenient() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement ps = session.prepare("INSERT INTO product2d (id, dimensions) VALUES (?, ?)");
    BoundStatementBuilder builder = ps.boundStatementBuilder();
    builder.setUuid(0, FLAMETHROWER.getId());
    UdtValue dimensionsUdt = dimensions2d.newValue();
    Dimensions dimensions = new Dimensions(12, 34, 56);
    dao.setLenient(dimensions, dimensionsUdt);
    builder.setUdtValue(1, dimensionsUdt);
    assertThat(dimensionsUdt.getInt("width")).isEqualTo(34);
    assertThat(dimensionsUdt.getInt("height")).isEqualTo(56);
  }

  @Test
  public void should_not_set_entity_on_partial_statement_when_not_lenient() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement ps = session.prepare("INSERT INTO product (id, description) VALUES (?, ?)");
    Throwable error = catchThrowable(() -> dao.set(FLAMETHROWER, ps.bind()));
    assertThat(error).hasMessage("dimensions is not a variable in this bound statement");
  }

  @Test
  public void should_not_set_entity_on_partial_statement_builder_when_not_lenient() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement ps = session.prepare("INSERT INTO product (id, description) VALUES (?, ?)");
    Throwable error = catchThrowable(() -> dao.set(ps.boundStatementBuilder(), FLAMETHROWER));
    assertThat(error).hasMessage("dimensions is not a variable in this bound statement");
  }

  @Test
  @SuppressWarnings("ResultOfMethodCallIgnored")
  public void should_not_set_entity_on_partial_udt_when_not_lenient() {
    CqlSession session = SESSION_RULE.session();
    PreparedStatement ps = session.prepare("INSERT INTO product2d (id, dimensions) VALUES (?, ?)");
    BoundStatementBuilder builder = ps.boundStatementBuilder();
    builder.setUuid(0, FLAMETHROWER.getId());
    UdtValue dimensionsUdt = dimensions2d.newValue();
    Dimensions dimensions = new Dimensions(12, 34, 56);
    Throwable error = catchThrowable(() -> dao.set(dimensions, dimensionsUdt));
    assertThat(error).hasMessage("length is not a field in this UDT");
  }

  private static void assertMatches(GettableByName data, Product entity) {
    assertThat(data.getUuid("id")).isEqualTo(entity.getId());
    assertThat(data.getString("description")).isEqualTo(entity.getDescription());
    UdtValue udtValue = data.getUdtValue("dimensions");
    assertThat(udtValue).isNotNull();
    assertThat(udtValue.getType().getName().asInternal()).isEqualTo("dimensions");
    assertThat(udtValue.getInt("length")).isEqualTo(entity.getDimensions().getLength());
    assertThat(udtValue.getInt("width")).isEqualTo(entity.getDimensions().getWidth());
    assertThat(udtValue.getInt("height")).isEqualTo(entity.getDimensions().getHeight());
  }

  @Mapper
  public interface InventoryMapper {
    @DaoFactory
    ProductDao productDao(@DaoKeyspace CqlIdentifier keyspace);
  }

  @Dao
  public interface ProductDao {

    @SetEntity
    BoundStatement set(Product product, BoundStatement boundStatement);

    @SetEntity(nullSavingStrategy = NullSavingStrategy.SET_TO_NULL)
    void setNullFields(BoundStatementBuilder builder, Product product);

    @SetEntity(nullSavingStrategy = NullSavingStrategy.DO_NOT_SET)
    void setDoNotSetNullFields(BoundStatementBuilder builder, Product product);

    @SetEntity
    void set(BoundStatementBuilder builder, Product product);

    @SetEntity
    void set(Dimensions dimensions, UdtValue udtValue);

    @SetEntity(lenient = true)
    BoundStatement setLenient(Product product, BoundStatement boundStatement);

    @SetEntity(lenient = true)
    void setLenient(Product product, BoundStatementBuilder builder);

    @SetEntity(lenient = true)
    void setLenient(Dimensions dimensions, UdtValue udtValue);
  }
}
