#ifndef __LIGHTING_INC
#define __LIGHTING_INC

#include "UnityCG.cginc"
#include "AutoLight.cginc"
#include "UnityPBSLighting.cginc"
#include "UnityLightingCommon.cginc"
#include "UnityStandardCoreMinimal.cginc"

#include "features.cginc"
#include "filamented.cginc"
#include "interpolators.cginc"
#include "LightVolumes.cginc"
#include "pbr.cginc"

struct LightCommon {
  float3 V;
  float3 N;
  float NoV;
#if defined(_CLEARCOAT)
  float NoV_cc;
#endif
};

struct LightDirect {
  float3 dir;

   float3 H;
   float NoH;
   float NoL;
#if defined(_CLEARCOAT)
   float NoH_cc;
   float NoL_cc;
#endif
   float LoH;
   float LoV;
   float double_LoV;

   float3 color;
};

struct LightIndirect {
  float3 dir;

   float3 H;
   float NoH;
   float NoL;
#if defined(_CLEARCOAT)
   float LoH_cc;
#endif
   float LoH;
   float LoV;
   float double_LoV;

   float3 specular;
#if defined(_CLEARCOAT)
   float3 specular_cc;
#endif
   float3 diffuse;

   float3 L00;
   float3 L01r;
   float3 L01g;
   float3 L01b;
};

struct LightData {
  LightCommon common;
  LightDirect direct;
  LightIndirect indirect;
};

float3 getDirectLightDirection(v2f i) {
#if defined(POINT) || defined(POINT_COOKIE) || defined(SPOT)
	return normalize((_WorldSpaceLightPos0 - i.worldPos).xyz);
#else
	return _WorldSpaceLightPos0;
#endif
}

float getShadowAttenuation(v2f i)
{
  UNITY_LIGHT_ATTENUATION(attenuation, i, i.worldPos);
	return attenuation;
}

float4 getDirectLightColorIntensity() {
	// Properly separate light color from intensity like filamented
	if (_LightColor0.w <= 0) return float4(0, 0, 0, 0);
	_LightColor0 += 1e-6f;
	return float4(_LightColor0.xyz / _LightColor0.w, _LightColor0.w);
}

float3 getIndirectSpecular(v2f i, float roughness, float3 view_dir, float3 reflect_dir) {
  UnityGIInput data = InitialiseUnityGIInput(i.worldPos, view_dir);
  float3 env_refl = UnityGI_prefilteredRadiance(data, roughness, reflect_dir);
  return env_refl;
}

float3 yumSH9(float4 n, float3 worldPos, inout LightIndirect light) {
  [branch]
  if (_UdonLightVolumeEnabled) {
    LightVolumeSH(worldPos, light.L00, light.L01r, light.L01g, light.L01b);
    return light.L00 + float3(
        dot(light.L01r, n.xyz),
        dot(light.L01g, n.xyz),
        dot(light.L01b, n.xyz));
  }

  // No light volumes - use SH9
  // Unity gives us the first three bands (L0-L2) of SH coefficients as follows:
  //   unity_SHA*.w:   L0 coefficients
  //   unity_SHA*.xyz: L1 coefficients
  //   unity_SHB*:     first four of the L2 coefficients
  //   unity_SHC:      last L2 coefficient

  // L0 band
  float3 L0 = float3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w);

  // L1 band
  float3 L1 = float3(
    dot(unity_SHAr.xyz, n.xyz),
    dot(unity_SHAg.xyz, n.xyz),
    dot(unity_SHAb.xyz, n.xyz)
  );

  // L2 band
  float4 v = float4(n.x * n.y, n.y * n.z, n.z * n.z, n.x * n.z);
  float3 L2 =
    float3(dot(unity_SHBr.xyzw, v), dot(unity_SHBg.xyzw, v), dot(unity_SHBb.xyzw, v)) +
    unity_SHC.xyz * (n.x * n.x - n.y * n.y);

  // TODO expose this as a parameter
  float wrap_term = 0.0f;

  // Original coefficients: 1, 2/3, 1/4.
  // Wrapped coefficients: 1, (2-w)/3, ((1-w)^2)/4.
  float l1_wrap = 1.0f - wrap_term * 0.75f;
  L1 *= l1_wrap;

  float l2_wrap_base = 1.0f - wrap_term;
  float l2_wrap = l2_wrap_base * l2_wrap_base;
  L2 *= l2_wrap;

  light.L00 = L0;
  light.L01r = unity_SHAr.xyz * l1_wrap;
  light.L01g = unity_SHAg.xyz * l1_wrap;
  light.L01b = unity_SHAb.xyz * l1_wrap;

  return L0 + L1 + L2;
}

float4 getIndirectDiffuse(v2f i, Pbr pbr, inout LightIndirect light) {
  float4 diffuse = 0;
#if defined(FORWARD_BASE_PASS)
  diffuse.xyz += max(0, yumSH9(float4(pbr.normal, 0), i.worldPos, light));
#endif
  return diffuse;
}

void GetLighting(v2f i, Pbr pbr, out LightData data) {
	data = (LightData) 0;

	float3 view_dir = normalize(i.eyeVec.xyz);

	data.common.V = -view_dir;
	data.common.N = pbr.normal;
  data.common.NoV = saturate(dot(pbr.normal, data.common.V));
#if defined(_CLEARCOAT)
  data.common.NoV_cc = saturate(dot(i.normal, data.common.V));
#endif

	// Direct lighting
	data.direct.dir = getDirectLightDirection(i);
	data.direct.H = normalize(data.common.V + data.direct.dir);
	data.direct.NoL = saturate(dot(pbr.normal, data.direct.dir));
	data.direct.NoH = saturate(dot(pbr.normal, data.direct.H));
  data.direct.LoH = saturate(dot(data.direct.dir, data.direct.H));
#if defined(_CLEARCOAT)
  data.direct.NoH_cc = saturate(dot(i.normal, data.direct.H));
  data.direct.NoL_cc = saturate(dot(i.normal, data.direct.dir));
#endif
  float direct_LoV = dot(data.direct.dir, data.common.V);
  data.direct.LoV = saturate(direct_LoV);
  data.direct.double_LoV = saturate(2.0f * direct_LoV * direct_LoV - 1.0f);

	float4 lightColorIntensity = getDirectLightColorIntensity();
	data.direct.color = lightColorIntensity.rgb * lightColorIntensity.w;

	// Indirect lighting
  float3 reflect_dir = -reflect(data.common.V, pbr.normal);
  float3 dominant_dir = getSpecularDominantDirection(pbr.normal, reflect_dir, pbr.roughness);

  data.indirect.dir = normalize(dominant_dir);
	data.indirect.H = normalize(data.common.V + data.indirect.dir);
	data.indirect.NoL = saturate(dot(pbr.normal, data.indirect.dir));
	data.indirect.NoH = saturate(dot(pbr.normal, data.indirect.H));
#if defined(_CLEARCOAT)
  float3 dir_cc = -reflect(data.common.V, i.normal);
  float3 H_cc = normalize(data.common.V + dir_cc);
  data.indirect.LoH_cc = saturate(dot(dir_cc, H_cc));
#endif
  data.indirect.LoH = saturate(dot(data.indirect.dir, data.indirect.H));
  float indirect_LoV = dot(data.indirect.dir, data.common.V);
  data.indirect.LoV = saturate(indirect_LoV);
  data.indirect.double_LoV = saturate(2.0f * indirect_LoV * indirect_LoV - 1.0f);

	data.indirect.diffuse = getIndirectDiffuse(i, pbr, data.indirect);
	data.indirect.specular = getIndirectSpecular(i, pbr.roughness, view_dir, data.indirect.dir);
#if defined(_CLEARCOAT)
  data.indirect.specular_cc = getIndirectSpecular(i, pbr.cc_roughness, view_dir, dir_cc);
#if defined(_CLEARCOAT_MASK)
  float cc_mask = _Clearcoat_Mask.Sample(bilinear_clamp_s, i.uv01.xy).r;
  data.indirect.specular_cc *= cc_mask;
#endif
#endif
}

#endif  // __LIGHTING_INC