/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

namespace ZXing.Common.ReedSolomon
{
    /// <summary> <p>Implements Reed-Solomon decoding, as the name implies.</p>
    /// 
    /// <p>The algorithm will not be explained here, but the following references were helpful
    /// in creating this implementation:</p>
    /// 
    /// <ul>
    /// <li>Bruce Maggs.
    /// <a href="http://www.cs.cmu.edu/afs/cs.cmu.edu/project/pscico-guyb/realworld/www/rs_decode.ps">
    /// "Decoding Reed-Solomon Codes"</a> (see discussion of Forney's Formula)</li>
    /// <li>J.I. Hall. <a href="www.mth.msu.edu/~jhall/classes/codenotes/GRS.pdf">
    /// "Chapter 5. Generalized Reed-Solomon Codes"</a>
    /// (see discussion of Euclidean algorithm)</li>
    /// </ul>
    /// 
    /// <p>Much credit is due to William Rucklidge since portions of this code are an indirect
    /// port of his C++ Reed-Solomon implementation.</p>
    /// 
    /// </summary>
    /// <author>Sean Owen</author>
    /// <author>William Rucklidge</author>
    /// <author>sanfordsquires</author>
    public sealed class ReedSolomonDecoder
    {
        private readonly GenericGF field;

        /// <summary>
        /// constructor
        /// </summary>
        /// <param name="field"></param>
        public ReedSolomonDecoder(GenericGF field)
        {
            this.field = field;
        }

        /// <summary>
        ///   <p>Decodes given set of received codewords, which include both data and error-correction
        /// codewords. Really, this means it uses Reed-Solomon to detect and correct errors, in-place,
        /// in the input.</p>
        /// </summary>
        /// <param name="received">data and error-correction codewords</param>
        /// <param name="twoS">number of error-correction codewords available</param>
        /// <returns>false: decoding fails</returns>
        public bool decode(int[] received, int twoS)
        {
            var poly = new GenericGFPoly(field, received);
            var syndromeCoefficients = new int[twoS];
            var noError = true;
            for (var i = 0; i < twoS; i++)
            {
                var eval = poly.evaluateAt(field.exp(i + field.GeneratorBase));
                syndromeCoefficients[syndromeCoefficients.Length - 1 - i] = eval;
                if (eval != 0)
                {
                    noError = false;
                }
            }
            if (noError)
            {
                return true;
            }
            var syndrome = new GenericGFPoly(field, syndromeCoefficients);

            var sigmaOmega = runEuclideanAlgorithm(field.buildMonomial(twoS, 1), syndrome, twoS);
            if (sigmaOmega == null)
                return false;

            var sigma = sigmaOmega[0];
            var errorLocations = findErrorLocations(sigma);
            if (errorLocations == null)
                return false;

            var omega = sigmaOmega[1];
            var errorMagnitudes = findErrorMagnitudes(omega, errorLocations);
            for (var i = 0; i < errorLocations.Length; i++)
            {
                var position = received.Length - 1 - field.log(errorLocations[i]);
                if (position < 0)
                {
                    // throw new ReedSolomonException("Bad error location");
                    return false;
                }
                received[position] = GenericGF.addOrSubtract(received[position], errorMagnitudes[i]);
            }

            return true;
        }

        internal GenericGFPoly[] runEuclideanAlgorithm(GenericGFPoly a, GenericGFPoly b, int R)
        {
            // Assume a's degree is >= b's
            if (a.Degree < b.Degree)
            {
                GenericGFPoly temp = a;
                a = b;
                b = temp;
            }

            GenericGFPoly rLast = a;
            GenericGFPoly r = b;
            GenericGFPoly tLast = field.Zero;
            GenericGFPoly t = field.One;

            // Run Euclidean algorithm until r's degree is less than R/2
            while (r.Degree >= R / 2)
            {
                GenericGFPoly rLastLast = rLast;
                GenericGFPoly tLastLast = tLast;
                rLast = r;
                tLast = t;

                // Divide rLastLast by rLast, with quotient in q and remainder in r
                if (rLast.isZero)
                {
                    // Oops, Euclidean algorithm already terminated?
                    // throw new ReedSolomonException("r_{i-1} was zero");
                    return null;
                }
                r = rLastLast;
                GenericGFPoly q = field.Zero;
                int denominatorLeadingTerm = rLast.getCoefficient(rLast.Degree);
                int dltInverse = field.inverse(denominatorLeadingTerm);
                while (r.Degree >= rLast.Degree && !r.isZero)
                {
                    int degreeDiff = r.Degree - rLast.Degree;
                    int scale = field.multiply(r.getCoefficient(r.Degree), dltInverse);
                    q = q.addOrSubtract(field.buildMonomial(degreeDiff, scale));
                    r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale));
                }

                t = q.multiply(tLast).addOrSubtract(tLastLast);

                if (r.Degree >= rLast.Degree)
                {
                    // throw new IllegalStateException("Division algorithm failed to reduce polynomial?");
                    return null;
                }
            }

            int sigmaTildeAtZero = t.getCoefficient(0);
            if (sigmaTildeAtZero == 0)
            {
                // throw new ReedSolomonException("sigmaTilde(0) was zero");
                return null;
            }

            int inverse = field.inverse(sigmaTildeAtZero);
            GenericGFPoly sigma = t.multiply(inverse);
            GenericGFPoly omega = r.multiply(inverse);
            return new GenericGFPoly[] { sigma, omega };
        }

        private int[] findErrorLocations(GenericGFPoly errorLocator)
        {
            // This is a direct application of Chien's search
            int numErrors = errorLocator.Degree;
            if (numErrors == 1)
            {
                // shortcut
                return new int[] { errorLocator.getCoefficient(1) };
            }
            int[] result = new int[numErrors];
            int e = 0;
            for (int i = 1; i < field.Size && e < numErrors; i++)
            {
                if (errorLocator.evaluateAt(i) == 0)
                {
                    result[e] = field.inverse(i);
                    e++;
                }
            }
            if (e != numErrors)
            {
                // throw new ReedSolomonException("Error locator degree does not match number of roots");
                return null;
            }
            return result;
        }

        private int[] findErrorMagnitudes(GenericGFPoly errorEvaluator, int[] errorLocations)
        {
            // This is directly applying Forney's Formula
            int s = errorLocations.Length;
            int[] result = new int[s];
            for (int i = 0; i < s; i++)
            {
                int xiInverse = field.inverse(errorLocations[i]);
                int denominator = 1;
                for (int j = 0; j < s; j++)
                {
                    if (i != j)
                    {
                        //denominator = field.multiply(denominator,
                        //    GenericGF.addOrSubtract(1, field.multiply(errorLocations[j], xiInverse)));
                        // Above should work but fails on some Apple and Linux JDKs due to a Hotspot bug.
                        // Below is a funny-looking workaround from Steven Parkes
                        int term = field.multiply(errorLocations[j], xiInverse);
                        int termPlus1 = (term & 0x1) == 0 ? term | 1 : term & ~1;
                        denominator = field.multiply(denominator, termPlus1);

                        // removed in java version, not sure if this is right
                        // denominator = field.multiply(denominator, GenericGF.addOrSubtract(1, field.multiply(errorLocations[j], xiInverse)));
                    }
                }
                result[i] = field.multiply(errorEvaluator.evaluateAt(xiInverse), field.inverse(denominator));
                if (field.GeneratorBase != 0)
                {
                    result[i] = field.multiply(result[i], xiInverse);
                }
            }
            return result;
        }
    }
}