import { ItemStack } from './item';
import { Hand, Identifier, Pos, JavaObjectWrapper } from './core';
import { World } from './world';
import { CompoundTag } from './tag';
import { useBridge } from 'scriptcraft-core';
import { Inventory } from './inventory';

function buildDamageSource(bridge: string): DamageSource {
    const obj = useBridge(bridge) as JavaObject;
    if (obj !== null) {
        return new DamageSource(obj);
    } else {
        return null;
    }
}

function buildDamageSourceWithValue(bridge: string, value: BridgeValueType): DamageSource {
    const obj = useBridge(bridge, value) as JavaObject;
    if (obj !== null) {
        return new DamageSource(obj);
    } else {
        return null;
    }
}

/**
 * Damage Source
 */
export class DamageSource extends JavaObjectWrapper {
    /**
     * Generic Damage Source
     */
    static GENERIC = buildDamageSource('DamageSource.getGeneric');
    /**
     * Void Damage Source
     */
    static OUT_OF_WORLD = buildDamageSource('DamageSource.getOutOfWorld');

    /**
     * Create Damage Source Wrapper From Java Object
     * @param javaObject Java Object
     */
    constructor(javaObject: JavaObject | JavaObjectWrapper) {
        super(javaObject);
        this.assertValidJavaObject('DamageSource');
    }

    /**
     * Create Damage Source from an explosion
     * @param value Explosion Source
     * @returns Damage Source
     */
    static createFromExplosion(value: LivingEntity): DamageSource {
        return buildDamageSourceWithValue('DamageSource.explosion', value.getJavaObject());
    }

    /**
     * Create Damage Source from a player ({@link PlayerEntity})
     * @param value Player
     * @returns Damage Source
     */
    static createFromPlayer(value: PlayerEntity): DamageSource {
        return buildDamageSourceWithValue('DamageSource.createFromPlayer', value.getJavaObject());
    }

    /**
     * Create Damage Source from a mob ({@link LivingEntity})
     * @param value Mob
     * @returns Damage Source
     */
    static createFromMob(value: LivingEntity): DamageSource {
        return buildDamageSourceWithValue('DamageSource.createFromMob', value.getJavaObject());
    }
}

/**
 * Entity
 */
export class Entity extends JavaObjectWrapper {
    /**
     * Create Entity Wrapper Class From Existing Entity Or Java Object
     * @param object Existing Entity Or Java Object
     */
    constructor(javaObject: JavaObject | JavaObjectWrapper) {
        super(javaObject);
        this.assertValidJavaObject('Entity');
    }

    /**
     * Get Entity World
     * @returns Entity World
     */
    getEntityWorld(): World {
        const obj = useBridge('Entity.getEntityWorld', this.getJavaObject()) as JavaObject;
        if (obj !== null) {
            return new World(obj);
        } else {
            return null;
        }
    }

    /**
     * Get Entity ID
     * @returns Entity ID
     */
    getID(): Identifier {
        const obj = useBridge('Entity.getID', this.getJavaObject()) as string;
        if (obj !== null) {
            return new Identifier(obj);
        } else {
            return null;
        }
    }

    /**
     * Get Entity Name
     * @returns Entity Name
     */
    getName(): string {
        return useBridge('Entity.getName', this.getJavaObject()) as string;
    }

    /**
     * Get Entity Display Name
     * @returns Entity Display Name
     */
    getDisplayName(): string {
        return useBridge('Entity.getDisplayName', this.getJavaObject()) as string;
    }

    /**
     * Get Entity Custom Name
     * @returns Entity Custom Name
     */
    getCustomName(): string {
        return useBridge('Entity.getCustomName', this.getJavaObject()) as string;
    }

    /**
     * Convert To String
     * @returns String
     */
    toString(): string {
        return this.getName();
    }

    /**
     * Kill Entity
     */
    kill(): void {
        useBridge('Entity.kill', this.getJavaObject());
    }

    /**
     * Remove Entity
     */
    remove(): void {
        useBridge('Entity.remove', this.getJavaObject());
    }

    /**
     * Set Entity Fire Ticks
     * @param ticks Fire Ticks
     */
    setFireTicks(ticks: number): void {
        useBridge('Entity.setFireTicks', this.getJavaObject(), ticks);
    }

    /**
     * Get Entity Fire Ticks
     * @returns Fire Ticks
     */
    getFireTicks(): number {
        return useBridge('Entity.getFireTicks', this.getJavaObject()) as number;
    }

    /**
     * Damage Entity
     * @param source Damage Source
     * @param amount Damage Amount
     */
    damage(source: DamageSource, amount: number): void {
        useBridge('Entity.damage', source.getJavaObject(), amount);
    }

    /**
     * Get Entity Position
     * @returns Entity Position
     */
    getPosition(): Pos {
        const pos: number[] = useBridge('Entity.getPosition', this.getJavaObject()) as number[];
        if (pos !== null && pos.length === 3) {
            return new Pos(pos[0], pos[1], pos[2]);
        } else {
            return null;
        }
    }

    /**
     * Set Entity Position
     * @param pos Entity Position
     */
    setPosition(pos: Pos): void {
        useBridge('Entity.setPosition', this.getJavaObject(), pos.getX(), pos.getY(), pos.getZ());
    }

    /**
     * Save Data To {@link CompoundTag}
     * @returns Tag
     */
    toTag(): CompoundTag {
        const obj = useBridge('Entity.toTag', this.getJavaObject()) as JavaObject;
        if (obj !== null) {
            return new CompoundTag(obj);
        } else {
            return null;
        }
    }

    /**
     * Load Data From {@link CompoundTag}
     * @param tag Tag
     */
    fromTag(tag: CompoundTag): void {
        useBridge('Entity.fromTag', this.getJavaObject(), tag.getJavaObject());
    }
}

/**
 * Living Entity
 */
export class LivingEntity extends Entity {
    constructor(javaObject: JavaObject | JavaObjectWrapper) {
        super(javaObject);
        this.assertValidJavaObject('LivingEntity');
    }

    /**
     * Get Stack in {@link Hand}
     * @param hand Hand
     * @returns Item Stack
     */
    getStackInHand(hand: Hand): ItemStack {
        const obj = useBridge('LivingEntity.getStackInHand', this.getJavaObject(), hand.toString()) as JavaObject;
        if (obj !== null) {
            return new ItemStack(obj);
        } else {
            return null;
        }
    }

    /**
     * Get Health
     * @returns Entity Health
     */
    getHealth(): number {
        return useBridge('LivingEntity.getHealth', this.getJavaObject()) as number;
    }
}

/**
 * Player Entity
 */
export class PlayerEntity extends LivingEntity {
    constructor(javaObject: JavaObject | JavaObjectWrapper) {
        super(javaObject);
        this.assertValidJavaObject('PlayerEntity');
    }

    getInventory(): Inventory {
        const obj = useBridge('PlayerEntity.getInventory', this.getJavaObject()) as JavaObject;
        if (obj !== null) {
            return new Inventory(obj);
        } else {
            return null;
        }
    }
}