package me.km.entities;

import java.nio.charset.StandardCharsets;
import me.km.KajetansMod;
import me.km.Server;
import me.km.networking.ModPacketHandler;
import me.km.overrides.ModEntityPlayerMP;
import me.km.snuviscript.ScriptEvents;
import net.minecraft.entity.Entity;
import net.minecraft.entity.CreatureEntity;
import net.minecraft.entity.EntitySize;
import net.minecraft.entity.EntityType;
import net.minecraft.entity.Pose;
import net.minecraft.entity.SharedMonsterAttributes;
import net.minecraft.entity.ai.goal.LookAtGoal;
import net.minecraft.entity.ai.goal.LookRandomlyGoal;
import net.minecraft.entity.ai.goal.SwimGoal;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.nbt.CompoundNBT;
import net.minecraft.network.PacketBuffer;
import net.minecraft.util.DamageSource;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.SoundEvent;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.world.World;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import net.minecraftforge.fml.common.registry.IEntityAdditionalSpawnData;
import net.minecraft.util.SoundEvents;

public class EntityHuman extends CreatureEntity implements IEntityAdditionalSpawnData
{
    private final static String STEVE = "Steve";
    
    @OnlyIn(Dist.CLIENT)
    private ResourceLocation texture;
    
    private String name;
    private float scale;
    private byte slim;
    private final float originalWidth;
    private final float originalHeight;
    private EntitySize size;
    
    public EntityHuman(EntityType<EntityHuman> type, World w)
    {
        super(type, w);  
        this.name = STEVE;
        this.scale = 1;
        this.originalWidth = getWidth();
        this.originalHeight = getHeight();
        this.slim = 0;
        size = ModEntities.HUMAN.getSize();
    }

    // -------------------------------------------------------------------------
    // size modifier
    // -------------------------------------------------------------------------

    public byte getSlim()
    {
        return slim;
    }
    
    public void setSlim(byte slim)
    {
        this.slim = slim;
    }
    
    public void setSlim(boolean b)
    {
        this.slim = (byte) (b ? 1 : 0);
        if(!this.world.isRemote)
        {
            ModPacketHandler.sendHumanScaleUpdate(this);
        }
    }
    
    public boolean isSlim()
    {
        return this.slim == 1;
    }
    
    public final float getScale()
    {
        return scale;
    }
    
    public final void setScale(float scale)
    {
        this.scale = scale;
        this.setSize(originalWidth * scale, originalHeight * scale);
        if(!this.world.isRemote)
        {
            ModPacketHandler.sendHumanScaleUpdate(this);
        }
    }
    
    // -------------------------------------------------------------------------
    // texture stuff
    // -------------------------------------------------------------------------
    
    @OnlyIn(Dist.CLIENT)
    public ResourceLocation getTexture()
    {
        return texture;
    }
    
    @OnlyIn(Dist.CLIENT)
    public void setTexture(ResourceLocation texture)
    {
        this.texture = texture;
    }
    
    @Override
    public void readAdditional(CompoundNBT com)
    {
        super.readAdditional(com);
        if(com.contains("HumanName"))
        {
            this.name = com.getString("HumanName");
        }
        if(com.contains("Scale"))
        {
            this.scale = com.getFloat("Scale");
            setSize(originalWidth * scale, originalHeight * scale);
        }
        if(com.contains("Slim"))
        {
            this.slim = com.getByte("Slim");
        }
    }

    @Override
    public void writeAdditional(CompoundNBT com)
    {
        super.writeAdditional(com);
        com.putString("HumanName", name);
        com.putFloat("Scale", scale);
        com.putByte("Slim", slim);
    }
    
    @Override
    public void writeSpawnData(PacketBuffer buf) 
    {
        byte[] b = name.getBytes(StandardCharsets.UTF_8);
        buf.writeInt(b.length);
        buf.writeBytes(b);
        buf.writeFloat(scale);
        buf.writeByte(slim);
    }

    @Override
    public void readSpawnData(PacketBuffer buf) 
    {
        int length = buf.readInt();
        name = buf.readBytes(length).toString(StandardCharsets.UTF_8);
        setTexture(HumanSkinLoader.INSTANCE.getTexture(name, loc -> setTexture(loc)));
        scale = buf.readFloat();
        setSize(originalWidth * scale, originalHeight * scale);
        slim = buf.readByte();
    }
    
    // -------------------------------------------------------------------------

    @Override
    public void addVelocity(double x, double y, double z)
    {
    }
    
    @Override
    public void knockBack(Entity entityIn, float strength, double xRatio, double zRatio)
    {
    }
    
    @Override
    public void applyEntityCollision(Entity entityIn) 
    {
    }

    @Override
    public boolean attackEntityFrom(DamageSource source, float amount) 
    {
        if(source == DamageSource.OUT_OF_WORLD)
        {
            this.remove();
            return false;
        }
        if(!world.isRemote)
        {
            Entity ent = source.getTrueSource();
            if(ent instanceof ModEntityPlayerMP)
            {
                Server.scriptEvents.onHumanHurt((ModEntityPlayerMP) ent, this);
            }
        }
        return false;
    }
    
    @Override
    protected void registerGoals() 
    {
        this.goalSelector.addGoal(0, new SwimGoal(this));
        this.goalSelector.addGoal(1, new LookAtGoal(this, PlayerEntity.class, 6.0F));
        this.goalSelector.addGoal(2, new LookRandomlyGoal(this));
   }
    
    public void setSkinName(String name)
    {
        this.name = name;
        if(!this.world.isRemote)
        {
            ModPacketHandler.sendHumanUpdate(this);
        }
    }   
    
    public String getSkinName()
    {
        return name;
    }

    @Override
    protected void registerAttributes()
    {
        super.registerAttributes();
        this.getAttributes().registerAttribute(SharedMonsterAttributes.ATTACK_DAMAGE).setBaseValue(1);
        this.getAttribute(SharedMonsterAttributes.MOVEMENT_SPEED).setBaseValue(0.1d);
        this.getAttributes().registerAttribute(SharedMonsterAttributes.ATTACK_SPEED);
    }

    @Override
    protected SoundEvent getSwimSound()
    {
        return SoundEvents.ENTITY_PLAYER_SWIM;
    }

    @Override
    protected SoundEvent getSplashSound()
    {
        return SoundEvents.ENTITY_PLAYER_SPLASH;
    }

    @Override
    public SoundCategory getSoundCategory()
    {
        return SoundCategory.NEUTRAL;
    }

    @Override
    protected SoundEvent getHurtSound(DamageSource ds)
    {
        if (ds == DamageSource.ON_FIRE)
        {
            return SoundEvents.ENTITY_PLAYER_HURT_ON_FIRE;
        }
        else
        {
            return ds == DamageSource.DROWN ? SoundEvents.ENTITY_PLAYER_HURT_DROWN : SoundEvents.ENTITY_PLAYER_HURT;
        }
    }

    @Override
    protected SoundEvent getDeathSound()
    {
        return SoundEvents.ENTITY_PLAYER_DEATH;
    }

    @Override
    public double getYOffset()
    {
        return -0.35D;
    }

    @Override
    public float getAIMoveSpeed()
    {
        return (float) this.getAttribute(SharedMonsterAttributes.MOVEMENT_SPEED).getValue();
    }

    @Override
    protected SoundEvent getFallSound(int heightIn)
    {
        return heightIn > 4 ? SoundEvents.ENTITY_PLAYER_BIG_FALL : SoundEvents.ENTITY_PLAYER_SMALL_FALL;
    }

    @OnlyIn(Dist.CLIENT)
    @Override
    public boolean getAlwaysRenderNameTagForRender()
    {
        return true;
    }

    @Override
    public ITextComponent getDisplayName()
    {
        return getName();
    }

    @Override
    public float getEyeHeight(Pose p_213307_1_)
    {
        float f = getDefaultEyeHeight();
        if(getHeight() == 1.65F)
        {
            f -= 0.08F;
        }
        f *= scale;
        return f;
    }

    public float getDefaultEyeHeight()
    {
        return 1.62F;
    }

    @Override
    public boolean canDespawn(double distanceToClosestPlayer)
    {
        return false;
    }

    @Override
    public EntitySize getSize(Pose poseIn)
    {
        return size;
    }
    
    public void setSize(float w, float h)
    {
        size = EntitySize.fixed(w, h);
    }
}