using System;

namespace Science.Physics.GeneralPhysics
{
	/// <summary>
	/// ElectricPotential
	/// </summary>
	public class ElectricPotential : Scalar
	{
		private void SetDim()
		{
			this.DimensionMass = 1;
			this.DimensionLength = 2;
			this.DimensionTime = -2;
			this.DimensionCharge = -1;
		}
		public ElectricPotential()
		{
			SetDim();
		}
	    public double V
		{
			get{return this.Magnitude;}
			set{this.Magnitude=value;}
		}
		public ElectricPotential(ElectricCharge q0, PotentialEnergy U)
		{
			SetDim();			
			this.Magnitude = U.J/q0.C;
		}		
		public ElectricPotential(ElectricCharge q, Position r, Position p)
		{
			Vector del = p - r;
			this.V = Constant.CoulombConstant*q.C/del.Norm;
		}

        public ElectricPotential(Scalar.FunctionOfPosition VStatic)
            : base(VStatic)
		{
			SetDim();
		}
		public void At(Position r)
		{
			this.Set(r);
		}
		public double Difference(Position from, Position to)
		{
			this.Set(from);
			double Vi = this.Magnitude;
			
			this.Set(to);
			double Vf = this.Magnitude;
			return Vf - Vi;
		}

		private Position x0, xf;
		private double Vi = 0.0;
        private ElectricField e;
		public ElectricPotential(ElectricField E,
			Position referencePosition, ElectricPotential referenceValue)
		{
			SetDim();
            e = E;
          	x0 = referencePosition;
		    Vi = referenceValue.Magnitude;
		}		
		public double ValueAt(Position r)
		{
			xf = r;
            Line.Parameterization fun
                = new Line.Parameterization(rvst);
			Line p = new Line(fun);
			p.ParameterStartValue = 0.0;
			p.ParameterEndValue = 1.0;
            Time t = new Time();
            Scalar s = VectorCalculus.LineIntegralDot(e, p, t);
            return -s.Magnitude + Vi;
		}
		private Position rvst(double t)
		{
            Position r = new Position();
            r.X = (xf.X - x0.X) * t + x0.X;
            r.Y = (xf.Y - x0.Y) * t + x0.Y;
            r.Z = (xf.Z - x0.Z) * t + x0.Z;
            return r;
		}		

		private Scalar.FunctionOfPosition fp;
        private Position pp;
		
		public ElectricPotential(ChargeDensity rho, Volume v, Position p)
		{
			SetDim();
			fp = rho.ScalarFunctionOfPosition;
            pp = p;
            Scalar s = new Scalar();
            s.ScalarFunctionOfPosition = new FunctionOfPosition(rhoOVERr);
            Scalar ss = VectorCalculus.VolumeIntegral(s, v);
			
			this.Magnitude = Constant.CoulombConstant*ss.Magnitude;
            this.StandardDeviation = Constant.CoulombConstant * ss.StandardDeviation;
		}	
		private Scalar rhoOVERr(Position rr)
		{
			Scalar s = new Scalar();
            Position r = new Position();
            r.X = pp.X - rr.X;
            r.Y = pp.Y - rr.Y;
            r.Z = pp.Z - rr.Z;
			s.Magnitude = fp(rr).Magnitude/Math.Sqrt(r.X*r.X+r.Y*r.Y+r.Z*r.Z);
            return s;
		}
        public override string ToString()
        {
            return base.ToString() + "(V)";
        }
	}
}