#include "environment_builder.h"

#include "asset_io.h"
#include "dxt.h"

#include <godot_cpp/classes/environment.hpp>
#include <godot_cpp/classes/image.hpp>
#include <godot_cpp/classes/image_texture.hpp>
#include <godot_cpp/classes/procedural_sky_material.hpp>
#include <godot_cpp/classes/shader.hpp>
#include <godot_cpp/classes/shader_material.hpp>
#include <godot_cpp/classes/sky.hpp>
#include <godot_cpp/classes/texture2d.hpp>
#include <godot_cpp/core/object.hpp>

#include <m2_coord.h>

#include <algorithm>

using namespace godot;

namespace mtgodot {

namespace {

Color rgba(const fmt::Rgba &c) { return Color(c[0], c[1], c[2], c[3]); }
float luma(const fmt::Rgba &c) { return 0.2126f * c[0] + 0.7152f * c[1] + 0.0722f * c[2]; }

const char *SRC_SKYBOX = R"(shader_type sky;
render_mode use_debanding;

uniform sampler2D front_tex : source_color, filter_linear_mipmap_anisotropic;
uniform sampler2D back_tex : source_color, filter_linear_mipmap_anisotropic;
uniform sampler2D left_tex : source_color, filter_linear_mipmap_anisotropic;
uniform sampler2D right_tex : source_color, filter_linear_mipmap_anisotropic;
uniform sampler2D top_tex : source_color, filter_linear_mipmap_anisotropic;
uniform sampler2D bottom_tex : source_color, filter_linear_mipmap_anisotropic;
uniform bool has_front = false;
uniform bool has_back = false;
uniform bool has_left = false;
uniform bool has_right = false;
uniform bool has_top = false;
uniform bool has_bottom = false;
uniform vec4 gradient_top = vec4(0.2, 0.3, 0.6, 1.0);
uniform vec4 gradient_horizon = vec4(0.5, 0.6, 0.8, 1.0);
uniform vec4 gradient_bottom = vec4(0.2, 0.2, 0.25, 1.0);
uniform sampler2D cloud_tex : source_color, repeat_enable, filter_linear_mipmap_anisotropic;
uniform bool has_cloud = false;
uniform vec2 cloud_scale = vec2(2000.0, 2000.0);
uniform float cloud_height = 300.0;
uniform vec2 cloud_texture_scale = vec2(4.0, 4.0);
uniform vec2 cloud_speed = vec2(0.001, 0.001);
uniform vec4 cloud_tint = vec4(0.0, 0.0, 0.0, 0.0);

vec3 gradient_color(vec3 direction) {
	float height = clamp(direction.y * 0.5 + 0.5, 0.0, 1.0);
	if (height < 0.5)
		return mix(gradient_bottom.rgb, gradient_horizon.rgb, height * 2.0);
	return mix(gradient_horizon.rgb, gradient_top.rgb, (height - 0.5) * 2.0);
}

vec3 apply_cloud(vec3 color, vec3 direction) {
	if (!has_cloud || direction.y <= 0.001 || cloud_height <= 0.0 ||
			cloud_scale.x <= 0.001 || cloud_scale.y <= 0.001)
		return color;

	// ClientVS22 renders a finite horizontal quad at camera.z + CloudHeight.
	// After the Metin2 -> Godot conversion this is camera.y + height. The
	// source quad maps source +Y -> U=0 and source +X -> V=1; source Y is
	// Godot -Z, so keep that orientation here.
	float distance_to_cloud = cloud_height / direction.y;
	vec2 plane = direction.xz * distance_to_cloud;
	if (abs(plane.x) > cloud_scale.x || abs(plane.y) > cloud_scale.y)
		return color;
	vec2 uv = vec2(
			0.5 + 0.5 * plane.y / cloud_scale.y,
			0.5 + 0.5 * plane.x / cloud_scale.x);
	uv = fract(uv * cloud_texture_scale + TIME * cloud_speed);

	// SkyBox.cpp uses MODULATEINVALPHA_ADDCOLOR followed by ONE /
	// INVSRCCOLOR blending: cloud.rgb + sky * (1 - cloud.rgb).
	vec4 texel = texture(cloud_tex, uv);
	vec3 cloud_rgb = clamp(texel.rgb * (1.0 - cloud_tint.a) + cloud_tint.rgb,
			0.0, 1.0);
	return cloud_rgb + color * (1.0 - cloud_rgb);
}

void sky() {
	vec3 direction = normalize(EYEDIR);
	vec3 color = gradient_color(direction);
	float ax = abs(direction.x);
	float ay = abs(direction.y);
	float az = abs(direction.z);
	vec2 uv;

	// ClientVS22 uses Metin2 Z-up faces. After x,z,-y conversion:
	// front=+Z, back=-Z, left=+X, right=-X, top=+Y, bottom=-Y.
	if (az >= ax && az >= ay) {
		if (direction.z > 0.0) {
			uv = vec2(0.5 - 0.5 * direction.x / az,
				0.5 - 0.5 * direction.y / az);
			if (has_front)
				color = texture(front_tex, uv).rgb;
		} else {
			uv = vec2(0.5 + 0.5 * direction.x / az,
				0.5 - 0.5 * direction.y / az);
			if (has_back)
				color = texture(back_tex, uv).rgb;
		}
	} else if (ax >= ay) {
		if (direction.x > 0.0) {
			uv = vec2(0.5 + 0.5 * direction.z / ax,
				0.5 - 0.5 * direction.y / ax);
			if (has_left)
				color = texture(left_tex, uv).rgb;
		} else {
			uv = vec2(0.5 - 0.5 * direction.z / ax,
				0.5 - 0.5 * direction.y / ax);
			if (has_right)
				color = texture(right_tex, uv).rgb;
		}
	} else if (direction.y > 0.0) {
		uv = vec2(0.5 - 0.5 * direction.x / ay,
			0.5 - 0.5 * direction.z / ay);
		if (has_top)
			color = texture(top_tex, uv).rgb;
	} else {
		uv = vec2(0.5 - 0.5 * direction.x / ay,
			0.5 - 0.5 * direction.z / ay);
		if (has_bottom)
			color = texture(bottom_tex, uv).rgb;
	}
	COLOR = apply_cloud(color, direction);
}
)";

Ref<ImageTexture> solid_texture(const Color &color) {
	PackedByteArray pixels;
	pixels.resize(4);
	uint8_t *p = pixels.ptrw();
	p[0] = (uint8_t)std::round(std::clamp(color.r, 0.0f, 1.0f) * 255.0f);
	p[1] = (uint8_t)std::round(std::clamp(color.g, 0.0f, 1.0f) * 255.0f);
	p[2] = (uint8_t)std::round(std::clamp(color.b, 0.0f, 1.0f) * 255.0f);
	p[3] = (uint8_t)std::round(std::clamp(color.a, 0.0f, 1.0f) * 255.0f);
	Ref<godot::Image> image = godot::Image::create_from_data(
			1, 1, false, godot::Image::FORMAT_RGBA8, pixels);
	image->generate_mipmaps();
	return ImageTexture::create_from_image(image);
}

Ref<ImageTexture> load_texture(const std::string &name, const fmt::AssetResolver *resolver) {
	if (name.empty() || resolver == nullptr)
		return Ref<ImageTexture>();
	const std::string path = resolver->resolve(name, nullptr);
	if (path.empty())
		return Ref<ImageTexture>();
	Ref<godot::Image> image;
	const String godot_path(path.c_str());
	if (godot_path.get_extension().to_lower() == "dds") {
		const mtgodot::Image decoded = mtgodot::dds_from_file(godot_path);
		if (!decoded.ok())
			return Ref<ImageTexture>();
		PackedByteArray pixels;
		pixels.resize((int64_t)decoded.rgba.size());
		std::copy(decoded.rgba.begin(), decoded.rgba.end(), pixels.ptrw());
		image = godot::Image::create_from_data(decoded.w, decoded.h, false,
				godot::Image::FORMAT_RGBA8, pixels);
	} else {
		// Image::load_from_file cannot open the pack:// virtual filesystem.
		if (godot_path.begins_with("pack://")) {
			PackedByteArray bytes = mtgodot::read_file(godot_path);
			image.instantiate();
			if (godot_path.get_extension().to_lower() == "tga")
				image->load_tga_from_buffer(bytes);
			else if (godot_path.get_extension().to_lower() == "png")
				image->load_png_from_buffer(bytes);
			else if (godot_path.get_extension().to_lower() == "jpg")
				image->load_jpg_from_buffer(bytes);
		} else {
			image = godot::Image::load_from_file(godot_path);
		}
	}
	if (image.is_null() || image->is_empty())
		return Ref<ImageTexture>();
	image->generate_mipmaps();
	return ImageTexture::create_from_image(image);
}

} // namespace

EnvNodes apply_environment(const fmt::Environment &env, Node *parent,
		const fmt::AssetResolver *resolver) {
	EnvNodes out;

	// --- DirectionalLight (Background) ---
	out.sun = Object::cast_to<DirectionalLight3D>(parent->get_node_or_null(NodePath("Sun")));
	if (!out.sun) {
		out.sun = memnew(DirectionalLight3D);
		out.sun->set_name("Sun");
		parent->add_child(out.sun);
	}
	out.sun->set_cull_mask(1u << 0); // background / terrain layer
	out.sun->set_visible(env.dir_light.bg_enable);
	// .msenv Direction 是 Metin2 Z-up 向量（光传播方向）。
	fmt::m2coord::Vec3 d = fmt::m2coord::direction_to_godot(
			env.dir_light.direction[0], env.dir_light.direction[1], env.dir_light.direction[2]);
	Vector3 fwd(d.x, d.y, d.z);
	if (fwd.length() < 1e-4f)
		fwd = Vector3(-0.4f, -0.7f, -0.55f);
	fwd.normalize();
	// Godot 光沿自身 -Z 照射 -> basis 的 -Z = fwd
	Basis b = Basis::looking_at(fwd, Vector3(0, 1, 0));
	out.sun->set_transform(Transform3D(b, Vector3(0, 0, 0)));
	if (env.dir_light.bg_enable || luma(env.dir_light.bg_diffuse) > 0.01f) {
		out.sun->set_color(rgba(env.dir_light.bg_diffuse));
		out.sun->set_param(Light3D::PARAM_ENERGY,
				std::clamp(0.9f + luma(env.dir_light.bg_diffuse) * 0.4f, 0.7f, 1.6f));
	}
	out.sun->set_shadow(true);
	out.sun->set_param(Light3D::PARAM_SHADOW_NORMAL_BIAS, 2.0f);
	out.sun->set_param(Light3D::PARAM_SHADOW_BIAS, 0.06f);
	out.sun->set_param(Light3D::PARAM_SHADOW_MAX_DISTANCE, 500.0f);
	out.sun->set_param(Light3D::PARAM_SHADOW_SPLIT_1_OFFSET, 0.08f);
	out.sun->set_param(Light3D::PARAM_SHADOW_SPLIT_2_OFFSET, 0.22f);
	out.sun->set_param(Light3D::PARAM_SHADOW_SPLIT_3_OFFSET, 0.5f);
	out.sun->set_shadow_mode(DirectionalLight3D::SHADOW_PARALLEL_4_SPLITS);
	// 角色/物体的间接补光：暖色，能量取自 Material.Ambient
	out.sun->set_param(Light3D::PARAM_SPECULAR, 0.4f);

	// ClientVS22 keeps the character light separate from the background light
	// (MapOutdoor::OnBeginEnvironment -> SpeedTree::SetLight).  Godot's light
	// cull mask is the closest exact scene-level equivalent: static world
	// geometry is layer 1, Metin2Model geometry is layer 2.
	out.character_light = Object::cast_to<DirectionalLight3D>(
			parent->get_node_or_null(NodePath("CharacterLight")));
	if (!out.character_light) {
		out.character_light = memnew(DirectionalLight3D);
		out.character_light->set_name("CharacterLight");
		parent->add_child(out.character_light);
	}
	out.character_light->set_cull_mask(1u << 1);
	out.character_light->set_visible(env.dir_light.ch_enable);
	out.character_light->set_transform(Transform3D(b, Vector3(0, 0, 0)));
	out.character_light->set_color(rgba(env.dir_light.ch_diffuse));
	out.character_light->set_param(Light3D::PARAM_ENERGY,
				std::clamp(0.9f + luma(env.dir_light.ch_diffuse) * 0.4f, 0.7f, 1.6f));
	out.character_light->set_shadow(false);
	out.character_light->set_param(Light3D::PARAM_SPECULAR, 0.4f);

	// --- WorldEnvironment ---
	out.world_env =
			Object::cast_to<WorldEnvironment>(parent->get_node_or_null(NodePath("WorldEnv")));
	if (!out.world_env) {
		out.world_env = memnew(WorldEnvironment);
		out.world_env->set_name("WorldEnv");
		parent->add_child(out.world_env);
	}
	Ref<godot::Environment> e = out.world_env->get_environment();
	if (e.is_null())
		e.instantiate();

	// 天空：SkyBox Gradient -> ProceduralSky 的三段色（zenith / horizon / ground）。
	// 参考端的 texture mode 是独立六面 quad；Godot Sky shader 用 EYEDIR 采样
	// 同一套六面图，坐标和 UV 依照 EterLib/SkyBox.cpp 的面顶点顺序转换。
	int sky_face_count = 0;
	bool sky_texture_applied = false;
	bool sky_cloud_applied = false;
	{
		Ref<ProceduralSkyMaterial> psm;
		psm.instantiate();
		const auto &g = env.sky.gradient;
		if (g.size() >= 2) {
			psm->set_sky_top_color(rgba(g.front()));
			psm->set_sky_horizon_color(rgba(g[g.size() / 2]));
			psm->set_ground_horizon_color(rgba(g.back()));
			Color gb = rgba(g.back());
			psm->set_ground_bottom_color(Color(gb.r * 0.6f, gb.g * 0.6f, gb.b * 0.65f));
		}
		psm->set_sun_angle_max(6.0f);
		Ref<Sky> sky;
		sky.instantiate();
		std::array<Ref<ImageTexture>, 6> faces;
		std::array<bool, 6> face_loaded{};
		for (int i = 0; i < 6; ++i) {
			if (env.sky.face_textures[i].empty())
				continue;
			faces[i] = load_texture(env.sky.face_textures[i], resolver);
			face_loaded[i] = faces[i].is_valid();
			if (face_loaded[i])
				++sky_face_count;
		}
		Ref<ImageTexture> cloud_texture;
		if (!env.sky.cloud_texture.empty())
			cloud_texture = load_texture(env.sky.cloud_texture, resolver);
		const bool use_texture_sky = env.sky.texture_render_mode && sky_face_count > 0;
		sky_texture_applied = use_texture_sky;
		if (use_texture_sky) {
			Ref<Shader> shader;
			shader.instantiate();
			shader->set_code(String(SRC_SKYBOX));
			Ref<ShaderMaterial> material;
			material.instantiate();
			material->set_shader(shader);
			Color fallback = g.empty() ? Color(0.35f, 0.45f, 0.7f, 1.0f) : rgba(g.front());
			Color horizon = g.size() < 2 ? fallback : rgba(g[g.size() / 2]);
			Color ground = g.empty() ? Color(0.2f, 0.2f, 0.25f, 1.0f) : rgba(g.back());
			material->set_shader_parameter("gradient_top", fallback);
			material->set_shader_parameter("gradient_horizon", horizon);
			material->set_shader_parameter("gradient_bottom", ground);
			static constexpr const char *kFaceParams[6] = {
				"front_tex", "back_tex", "left_tex", "right_tex", "top_tex", "bottom_tex"};
			static constexpr const char *kFaceFlags[6] = {
				"has_front", "has_back", "has_left", "has_right", "has_top", "has_bottom"};
			for (int i = 0; i < 6; ++i) {
				if (!faces[i].is_valid())
					faces[i] = solid_texture(i == 5 ? ground : horizon);
				material->set_shader_parameter(kFaceParams[i], faces[i]);
				material->set_shader_parameter(kFaceFlags[i], face_loaded[i]);
			}
			if (cloud_texture.is_valid()) {
				material->set_shader_parameter("cloud_tex", cloud_texture);
				material->set_shader_parameter("has_cloud", true);
				material->set_shader_parameter("cloud_scale", Vector2(
						std::max(env.sky.cloud_scale[0] * (float)fmt::m2coord::CM_TO_M, 0.01f),
						std::max(env.sky.cloud_scale[1] * (float)fmt::m2coord::CM_TO_M, 0.01f)));
				material->set_shader_parameter("cloud_height",
						std::max(env.sky.cloud_height * (float)fmt::m2coord::CM_TO_M, 0.01f));
				material->set_shader_parameter("cloud_texture_scale", Vector2(
						env.sky.cloud_texture_scale[0], env.sky.cloud_texture_scale[1]));
				material->set_shader_parameter("cloud_speed", Vector2(
						env.sky.cloud_speed[0], env.sky.cloud_speed[1]));
				Color tint = Color(0, 0, 0, 0);
				if (!env.sky.cloud_color.empty())
					tint = rgba(env.sky.cloud_color.front());
				material->set_shader_parameter("cloud_tint", tint);
				sky_cloud_applied = true;
			}
			sky->set_material(material);
		} else {
			sky->set_material(psm);
		}
		// Reference SkyBox scrolls clouds in its own renderer. Godot's procedural
		// sky has no equivalent UV-speed control, but sky_cover preserves the real
		// cloud asset and alpha/color instead of silently dropping CloudTextureFileName.
		if (!env.sky.cloud_texture.empty() && !use_texture_sky) {
			if (cloud_texture.is_valid()) {
				psm->set_sky_cover(cloud_texture);
				Color tint = Color(1, 1, 1, 1);
				if (!env.sky.cloud_color.empty())
					tint = rgba(env.sky.cloud_color.front());
				psm->set_sky_cover_modulate(tint);
				sky_cloud_applied = true;
			}
		}
		e->set_sky(sky);
		e->set_background(godot::Environment::BG_SKY);
	}

	// 环境光：Material.Ambient 定色 + 亮度（Metin2 用暖色环境光提亮阴影面）
	e->set_ambient_source(godot::Environment::AMBIENT_SOURCE_COLOR);
	Color amb = rgba(env.material.ambient);
	e->set_ambient_light_color(amb);
	e->set_ambient_light_energy(std::clamp(0.5f + luma(env.material.ambient) * 0.4f, 0.35f, 0.95f));
	e->set_ambient_light_sky_contribution(0.35f);
	// Emissive 当作全局轻微自发光提亮（避免死黑）
	e->set_bg_energy_multiplier(1.0f);

	// 雾：优先用 .msenv 的 NearDistance/FarDistance（cm，A1 = 5000/20000 -> 50/200m
	// 太近，客户端 D3DFOG 实际按更大的世界尺度；乘一个系数放到远景轻霭区）。没给
	// 距离就退回 foglevel 启发式。参考端是线性远景雾 + 天空同色，不是浓雾。
	if (env.fog.enable) {
		e->set_fog_enabled(true);
		e->set_fog_light_color(rgba(env.fog.color));
		e->set_fog_mode(godot::Environment::FOG_MODE_DEPTH);
		float begin_m, end_m;
		if (env.fog.near_distance > 1.0f && env.fog.far_distance > env.fog.near_distance) {
			begin_m = env.fog.near_distance * (float)fmt::m2coord::CM_TO_M;
			end_m = env.fog.far_distance * (float)fmt::m2coord::CM_TO_M;
			// 客户端摄距比我们远：把近雾往后推一截，别糊住中景
			begin_m = std::max(begin_m, 120.0f);
			end_m = std::max(end_m, begin_m + 400.0f);
		} else {
			float fl = env.fog.fog_level > 0 ? float(env.fog.fog_level) : 4.0f;
			begin_m = std::clamp((11.0f - fl) * 45.0f, 60.0f, 500.0f);
			end_m = begin_m + 700.0f;
		}
		e->set_fog_depth_begin(begin_m);
		e->set_fog_depth_end(end_m);
		e->set_fog_depth_curve(0.5f);
		e->set_fog_density(0.0f);
		e->set_fog_sky_affect(0.0f);   // 天空自己是渐变，不要被雾再洗一层
		e->set_fog_sun_scatter(0.05f);
	} else {
		e->set_fog_enabled(false);
	}

	// 色调：参考端是 DX9 定功能、LDR、无 tonemap/HDR。用 LINEAR + 曝光 1 最贴近，
	// Filmic 会抬黑、降饱和 -> 画面发灰。轻微加饱和/对比补回胶片感。
	e->set_tonemapper(godot::Environment::TONE_MAPPER_LINEAR);
	e->set_tonemap_exposure(1.0f);
	e->set_adjustment_enabled(true);
	e->set_adjustment_saturation(1.12f);
	e->set_adjustment_contrast(1.05f);
	e->set_adjustment_brightness(1.0f);
	// glow：参考端没有 bloom。留极轻的，只有真过曝才溢。
	e->set_glow_enabled(true);
	e->set_glow_intensity(0.06f);
	e->set_glow_strength(0.7f);
	e->set_glow_bloom(0.0f);
	e->set_glow_hdr_bleed_threshold(1.6f);
	// SSAO：参考端把接触阴影烘进地形阴影贴图。这里用一点实时 SSAO 代替。
	e->set_ssao_enabled(true);
	e->set_ssao_radius(1.2f);
	e->set_ssao_intensity(0.9f);

	// Keep parsed reference values visible to the runtime/debug probe even where
	// Godot has no 1:1 mapping (six cube faces, D3D blend factors, cloud motion,
	// and lens flare). This also prevents a future builder from silently losing
	// the fields while the renderer equivalent is being implemented.
	out.world_env->set_meta("msenv_sky_texture_mode", env.sky.texture_render_mode);
	out.world_env->set_meta("msenv_sky_face_count", sky_face_count);
	out.world_env->set_meta("msenv_sky_texture_mode_applied", sky_texture_applied);
	out.world_env->set_meta("msenv_sky_cloud_applied", sky_cloud_applied);
	out.world_env->set_meta("msenv_sky_scale",
			Vector3(env.sky.scale[0], env.sky.scale[1], env.sky.scale[2]));
	out.world_env->set_meta("msenv_cloud_scale",
			Vector2(env.sky.cloud_scale[0], env.sky.cloud_scale[1]));
	out.world_env->set_meta("msenv_cloud_height", env.sky.cloud_height);
	out.world_env->set_meta("msenv_cloud_texture_scale",
			Vector2(env.sky.cloud_texture_scale[0], env.sky.cloud_texture_scale[1]));
	out.world_env->set_meta("msenv_cloud_speed",
			Vector2(env.sky.cloud_speed[0], env.sky.cloud_speed[1]));
	out.world_env->set_meta("msenv_filter_enabled", env.filter.enable);
	out.world_env->set_meta("msenv_filter_color", rgba(env.filter.color));
	out.world_env->set_meta("msenv_filter_alpha_src", env.filter.alpha_src);
	out.world_env->set_meta("msenv_filter_alpha_dest", env.filter.alpha_dest);
	out.world_env->set_meta("msenv_lens_flare_enabled", env.lens_flare.enable);
	out.world_env->set_meta("msenv_lens_flare_texture", env.lens_flare.main_flare_texture.c_str());
	out.world_env->set_meta("msenv_background_light_enabled", env.dir_light.bg_enable);
	out.world_env->set_meta("msenv_character_light_enabled", env.dir_light.ch_enable);
	out.world_env->set_meta("msenv_background_light_ambient", rgba(env.dir_light.bg_ambient));
	out.world_env->set_meta("msenv_character_light_ambient", rgba(env.dir_light.ch_ambient));
	// MapUtil.cpp defaults; Environment_Load has no wind token to override these.
	out.world_env->set_meta("msenv_wind_strength", 0.2f);
	out.world_env->set_meta("msenv_wind_random", 0.0f);

	out.world_env->set_environment(e);
	return out;
}

} // namespace mtgodot