/**
 * java bean 復制操作的工具類
 *
 * @author rxliuli
 */
public class BeanCopyUtil<F, T> {
  /**
   * 源對象
   */
  private final F from;
  /**
   * 目標對象
   */
  private final T to;
  /**
   * 拷貝的字段信息列表
   */
  private final List<BeanCopyField> copyFieldList = new LinkedList<>();
  /**
   * 配置信息
   */
  private BeanCopyConfig config = new BeanCopyConfig();

  private BeanCopyUtil(F from, T to) {
    this.from = from;
    this.to = to;
  }

  /**
   * 指定需要拷貝的源對象和目標對象
   *
   * @param from 源對象
   * @param to  目標對象
   * @param <F> 源對象類型
   * @param <T> 目標對象類型
   * @return 一個 {@link BeanCopyUtil} 對象
   */
  public static <F, T> BeanCopyUtil<F, T> copy(F from, T to) {
    return new BeanCopyUtil<>(from, to);
  }

  /**
   * 拷貝指定對象的字段
   *
   * @param fromField 源對象中的字段名
   * @param toField  目標對象中的字段名
   * @param converter 將源對象中字段轉換為目標對象字段類型的轉換器
   * @return 返回 {@code this}
   */
  public BeanCopyUtil<F, T> prop(String fromField, String toField, Function<? super Object, ? super Object> converter) {
    copyFieldList.add(new BeanCopyField(fromField, toField, converter));
    return this;
  }

  /**
   * 拷貝指定對象的字段
   *
   * @param fromField 源對象中的字段名
   * @param toField  目標對象中的字段名
   * @return 返回 {@code this}
   */
  public BeanCopyUtil<F, T> prop(String fromField, String toField) {
    return prop(fromField, toField, null);
  }

  /**
   * 拷貝指定對象的字段
   *
   * @param field   源對象中與目標對象中的字段名
   * @param converter 將源對象中字段轉換為目標對象字段類型的轉換器
   * @return 返回 {@code this}
   */
  public BeanCopyUtil<F, T> prop(String field, Function<? super Object, ? super Object> converter) {
    return prop(field, field, converter);
  }

  /**
   * 拷貝指定對象的字段
   *
   * @param field 源對象中與目標對象中的字段名
   * @return 返回 {@code this}
   */
  public BeanCopyUtil<F, T> prop(String field) {
    return prop(field, field, null);
  }

  /**
   * 拷貝指定對象的多個字段
   *
   * @param fields 源對象中與目標對象中的多個字段名
   * @return 返回 {@code this}
   */
  public BeanCopyUtil<F, T> props(String... fields) {
    for (String field : fields) {
      prop(field);
    }
    return this;
  }

  /**
   * 執(zhí)行真正的拷貝操作
   *
   * @return 返回 {@code this}
   */
  public BeanCopyUtil<F, T> exec() {
    new BeanCopyOperator<>(from, to, copyFieldList, config).copy();
    return this;
  }

  /**
   * 重新開始添加其他對象的屬性
   * 用于在執(zhí)行完 {@link #exec()} 之后還想復制其它對象的屬性
   *
   * @param from 源對象
   * @param <R> 源對象類型
   * @return 一個新的 {@link BeanCopyUtil} 對象
   */
  public <R> BeanCopyUtil<R, T> from(R from) {
    return new BeanCopyUtil<>(from, to);
  }

  /**
   * 返回當前的目標對象
   *
   * @return 當前的目標對象
   */
  public T get() {
    return to;
  }

  /**
   * 配置拷貝的一些策略
   *
   * @param config 拷貝配置對象
   * @return 返回 {@code this}
   */
  public BeanCopyUtil<F, T> config(BeanCopyConfig config) {
    this.config = config;
    return this;
  }
}

/**
 * 拷貝屬性的每一個字段的選項
 *
 * @author rxliuli
 */
public class BeanCopyField {
  private String from;
  private String to;
  private Function<? super Object, ? super Object> converter;

  public BeanCopyField() {
  }

  public BeanCopyField(String from, String to, Function<? super Object, ? super Object> converter) {
    this.from = from;
    this.to = to;
    this.converter = converter;
  }

  public String getFrom() {
    return from;
  }

  public BeanCopyField setFrom(String from) {
    this.from = from;
    return this;
  }

  public String getTo() {
    return to;
  }

  public BeanCopyField setTo(String to) {
    this.to = to;
    return this;
  }

  public Function<? super Object, ? super Object> getConverter() {
    return converter;
  }

  public BeanCopyField setConverter(Function<? super Object, ? super Object> converter) {
    this.converter = converter;
    return this;
  }
}

/**
 * 拷貝屬性的配置
 *
 * @author rxliuli
 */
public class BeanCopyConfig {
  /**
   * 同名的字段自動復制
   */
  private boolean same = true;
  /**
   * 覆蓋同名的字段
   */
  private boolean override = true;
  /**
   * 忽略 {@code null} 的源對象屬性
   */
  private boolean ignoreNull = true;
  /**
   * 嘗試進行自動轉換
   */
  private boolean converter = true;

  public BeanCopyConfig() {
  }

  public BeanCopyConfig(boolean same, boolean override, boolean ignoreNull, boolean converter) {
    this.same = same;
    this.override = override;
    this.ignoreNull = ignoreNull;
    this.converter = converter;
  }

  public boolean isSame() {
    return same;
  }

  public BeanCopyConfig setSame(boolean same) {
    this.same = same;
    return this;
  }

  public boolean isOverride() {
    return override;
  }

  public BeanCopyConfig setOverride(boolean override) {
    this.override = override;
    return this;
  }

  public boolean isIgnoreNull() {
    return ignoreNull;
  }

  public BeanCopyConfig setIgnoreNull(boolean ignoreNull) {
    this.ignoreNull = ignoreNull;
    return this;
  }

  public boolean isConverter() {
    return converter;
  }

  public BeanCopyConfig setConverter(boolean converter) {
    this.converter = converter;
    return this;
  }
}

/**
 * 真正執(zhí)行 copy 屬性的類
 *
 * @author rxliuli
 */
public class BeanCopyOperator<F, T> {
  private static final Logger log = LoggerFactory.getLogger(BeanCopyUtil.class);
  private final F from;
  private final T to;
  private final BeanCopyConfig config;
  private List<BeanCopyField> copyFieldList;

  public BeanCopyOperator(F from, T to, List<BeanCopyField> copyFieldList, BeanCopyConfig config) {
    this.from = from;
    this.to = to;
    this.copyFieldList = copyFieldList;
    this.config = config;
  }

  public void copy() {
    //獲取到兩個對象所有的屬性
    final Map<String, Reflect> fromFields = Reflect.on(from).fields();
    final Reflect to = Reflect.on(this.to);
    final Map<String, Reflect> toFields = to.fields();
    //過濾出所有相同字段名的字段并進行拷貝
    if (config.isSame()) {
      final Map<ListUtil.ListDiffState, List<String>> different = ListUtil.different(new ArrayList<>(fromFields.keySet()), new ArrayList<>(toFields.keySet()));
      copyFieldList = Stream.concat(different.get(ListUtil.ListDiffState.common).stream()
          .map(s -> new BeanCopyField(s, s, null)), copyFieldList.stream())
          .collect(Collectors.toList());
    }
    //根據(jù)拷貝字段列表進行拷貝
    copyFieldList.stream()
        //忽略空值
        .filter(beanCopyField -> !config.isIgnoreNull() || fromFields.get(beanCopyField.getFrom()).get() != null)
        //覆蓋屬性
        .filter(beanCopyField -> config.isOverride() || toFields.get(beanCopyField.getTo()).get() == null)
        //如果沒有轉換器，則使用默認的轉換器
        .peek(beanCopyField -> {
          if (beanCopyField.getConverter() == null) {
            beanCopyField.setConverter(Function.identity());
          }
        })
        .forEach(beanCopyField -> {
          final String fromField = beanCopyField.getFrom();
          final F from = fromFields.get(fromField).get();
          final String toField = beanCopyField.getTo();
          try {
            to.set(toField, beanCopyField.getConverter().apply(from));
          } catch (ReflectException e) {
            log.warn("Copy field failed, from {} to {}, exception is {}", fromField, toField, e.getMessage());
          }
        });
  }
}

public class BeanCopyUtilTest {
  private final Logger log = LoggerFactory.getLogger(getClass());
  private Student student;
  private Teacher teacher;

  @Before
  public void before() {
    student = new Student("琉璃", 10, "女", 4);
    teacher = new Teacher();
  }

  @Test
  public void copy() {
    //簡單的復制（類似于 BeanUtils.copyProperties）
    BeanCopyUtil.copy(student, teacher).exec();
    log.info("teacher: {}", teacher);
    assertThat(teacher)
        .extracting("age")
        .containsOnlyOnce(student.getAge());
  }

  @Test
  public void prop() {
    //不同名字的屬性
    BeanCopyUtil.copy(student, teacher)
        .prop("sex", "sex", sex -> Objects.equals(sex, "男"))
        .prop("realname", "name")
        .exec();
    assertThat(teacher)
        .extracting("name", "age", "sex")
        .containsOnlyOnce(student.getRealname(), student.getAge(), false);
  }

  @Test
  public void prop1() {
    //不存的屬性
    assertThat(BeanCopyUtil.copy(student, teacher)
        .prop("sex", "sex", sex -> Objects.equals(sex, "男"))
        .prop("realname", "name2")
        .exec()
        .get())
        .extracting("age", "sex")
        .containsOnlyOnce(student.getAge(), false);
  }

  @Test
  public void from() {
    final Teacher lingMeng = new Teacher()
        .setName("靈夢")
        .setAge(17);
    //測試 from 是否覆蓋
    assertThat(BeanCopyUtil.copy(student, teacher)
        .prop("sex", "sex", sex -> Objects.equals(sex, "男"))
        .prop("realname", "name")
        .exec()
        .from(lingMeng)
        .exec()
        .get())
        .extracting("name", "age", "sex")
        .containsOnlyOnce(lingMeng.getName(), lingMeng.getAge(), false);
  }

  @Test
  public void get() {
    //測試 get 是否有效
    assertThat(BeanCopyUtil.copy(student, teacher)
        .prop("sex", "sex", sex -> Objects.equals(sex, "男"))
        .prop("realname", "name")
        .exec()
        .get())
        .extracting("name", "age", "sex")
        .containsOnlyOnce(student.getRealname(), student.getAge(), false);
  }

  @Test
  public void config() {
    //不自動復制同名屬性
    assertThat(BeanCopyUtil.copy(new Student().setAge(15), new Teacher())
        .config(new BeanCopyConfig().setSame(false))
        .exec()
        .get())
        .extracting("age")
        .containsOnlyNulls();
    //不覆蓋不為空的屬性
    assertThat(BeanCopyUtil.copy(new Student().setAge(15), new Teacher().setAge(10))
        .config(new BeanCopyConfig().setOverride(false))
        .exec()
        .get())
        .extracting("age")
        .containsOnlyOnce(10);
    //不忽略源對象不為空的屬性
    assertThat(BeanCopyUtil.copy(new Student(), student)
        .config(new BeanCopyConfig().setIgnoreNull(false))
        .exec()
        .get())
        .extracting("realname", "age", "sex", "grade")
        .containsOnlyNulls();
  }

  /**
   * 測試學生類
   */
  private static class Student {
    /**
     * 姓名
     */
    private String realname;
    /**
     * 年齡
     */
    private Integer age;
    /**
     * 性別，男/女
     */
    private String sex;
    /**
     * 年級，1 - 6
     */
    private Integer grade;

    public Student() {
    }

    public Student(String realname, Integer age, String sex, Integer grade) {
      this.realname = realname;
      this.age = age;
      this.sex = sex;
      this.grade = grade;
    }

    public String getRealname() {

      return realname;
    }

    public Student setRealname(String realname) {
      this.realname = realname;
      return this;
    }

    public Integer getAge() {
      return age;
    }

    public Student setAge(Integer age) {
      this.age = age;
      return this;
    }

    public String getSex() {
      return sex;
    }

    public Student setSex(String sex) {
      this.sex = sex;
      return this;
    }

    public Integer getGrade() {
      return grade;
    }

    public Student setGrade(Integer grade) {
      this.grade = grade;
      return this;
    }

    @Override
    public String toString() {
      return ToStringBuilder.reflectionToString(this);
    }
  }

  /**
   * 測試教師類
   */
  private static class Teacher {
    /**
     * 姓名
     */
    private String name;
    /**
     * 年齡
     */
    private Integer age;
    /**
     * 性別，true 男，false 女
     */
    private Boolean sex;
    /**
     * 職位
     */
    private String post;

    public Teacher() {
    }

    public Teacher(String name, Integer age, Boolean sex, String post) {
      this.name = name;
      this.age = age;
      this.sex = sex;
      this.post = post;
    }

    public String getName() {
      return name;
    }

    public Teacher setName(String name) {
      this.name = name;
      return this;
    }

    public Integer getAge() {
      return age;
    }

    public Teacher setAge(Integer age) {
      this.age = age;
      return this;
    }

    public Boolean getSex() {
      return sex;
    }

    public Teacher setSex(Boolean sex) {
      this.sex = sex;
      return this;
    }

    public String getPost() {
      return post;
    }

    public Teacher setPost(String post) {
      this.post = post;
      return this;
    }

    @Override
    public String toString() {
      return ToStringBuilder.reflectionToString(this);
    }
  }
}