package DNA;

import java.io.IOException;

import java.math.BigDecimal;

import java.util.function.Function;

import DNA.IO.*;

/**

* Number type in block. this type Can be accurate to 64-bit fixed-point, the rounding

* error to a minimum. By controlling the multiplier's accuracy,

* the rounding error can be completely eliminated

*

* @author 12146

* @since JDK1.8

*/

public class Fixed8 implements Comparable<Fixed8>, Serializable {

private static final long D = 100000000L;

private long value;

public static final Fixed8 MAX_VALUE = new Fixed8(Long.MAX_VALUE);

public static final Fixed8 MIN_VALUE = new Fixed8(Long.MIN_VALUE);

public static final Fixed8 ONE = new Fixed8(D);

public static final Fixed8 SATOSHI = new Fixed8(1);

public static final Fixed8 ZERO = new Fixed8(0);

public Fixed8() {

this(0);

}

public Fixed8(long data) {

this.value = data;

}

public Fixed8 abs() {

if (value >= 0) {

return this;

}

return new Fixed8(-value);

}

@Override

public int compareTo(Fixed8 other) {

return Long.compare(value, other.value);

}

@Override

public boolean equals(Object obj) {

if (!(obj instanceof Fixed8)) {

return false;

}

return value == ((Fixed8) obj).value;

}

public static Fixed8 fromDecimal(BigDecimal val) {

return new Fixed8(val.multiply(new BigDecimal(D)).longValueExact());

}

public static Fixed8 fromLong(long val) {

if (val < 0 || val > Long.MAX_VALUE / D) {

throw new IllegalArgumentException();

}

return new Fixed8(val * D);

}

public static Fixed8 parse(String s) {

return fromDecimal(new BigDecimal(s));

}

public long getData() {

return value;

}

@Override

public int hashCode() {

return Long.valueOf(value).hashCode();

}

public static Fixed8 max(Fixed8 first, Fixed8 ...others) {

for (Fixed8 other : others) {

if (first.compareTo(other) < 0) {

first = other;

}

}

return first;

}

public static Fixed8 min(Fixed8 first, Fixed8 ...others) {

for (Fixed8 other : others) {

if (first.compareTo(other) > 0) {

first = other;

}

}

return first;

}

public static Fixed8 sum(Fixed8[] values) {

return sum(values, p -> p);

}

public static <T> Fixed8 sum(T[] values, Function<T, Fixed8> selector) {

Fixed8 sum = Fixed8.ZERO;

for (T item : values) {

sum = sum.add(selector.apply(item));

}

return sum;

}

@Override

public String toString() {

BigDecimal v = new BigDecimal(value);

v = v.divide(new BigDecimal(D), 8, BigDecimal.ROUND_UNNECESSARY);

return v.toPlainString();

}

public static boolean tryParse(String s, Fixed8 result) {

try {

BigDecimal val = new BigDecimal(s);

result.value = val.longValueExact();

return true;

} catch(NumberFormatException | ArithmeticException ex) {

return false;

}

}

public long toLong() {

return value / D;

}

public Fixed8 multiply(long other) {

return new Fixed8(value * other);

}

public Fixed8 divide(long other) {

return new Fixed8(value / other);

}

public Fixed8 add(Fixed8 other) {

return new Fixed8(Math.addExact(this.value, other.value));

}

public Fixed8 subtract(Fixed8 other) {

return new Fixed8(Math.subtractExact(this.value, other.value));

}

public Fixed8 negate() {

return new Fixed8(-value);

}

@Override

public void serialize(BinaryWriter writer) throws IOException {

writer.writeLong(value);

}

@Override

public void deserialize(BinaryReader reader) throws IOException {

value = reader.readLong();

}

}