public int RedBarX { get; private set; }

        public int RedBarY { get; private set; }

        int pixelMultiplier = 1;

        InterfaceSize interfaceSize;

        bool firstRun = true;

        int lastSwatchX = -1;

        int lastSwatchY = -1;

        public int SwatchX { get { return lastSwatchX; } }

        public int SwatchY { get { return lastSwatchY; } }

        private static ReactionRecorder _instance;

        public static ReactionRecorder Instance

        {

            get {

                if (_instance == null)

                {

                    _instance = new ReactionRecorder();

                }

                return _instance;

            }

        }

        public StreamWriter Log { get; set; }

        private void WriteLog(string format, params object[] args)

        {

            if (Log != null)

            {

                Log.WriteLine(format, args);

            }

        }

        public delegate void ReactionRecordedHandler(Reagent reagent1, Reagent reagent2, Reaction reaction);

        public ReactionRecordedHandler OnReactionRecorded;

        public ReactionRecorder()

        {

            pixelMultiplier = 1;

            interfaceSize = DEFAULT_INTERFACE_SIZE;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

        public ReactionRecorder(int pixelMultiplier)

        {

            this.pixelMultiplier = pixelMultiplier;

            this.interfaceSize = DEFAULT_INTERFACE_SIZE;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

        public ReactionRecorder(int pixelMultiplier, InterfaceSize interfaceSize)

        {

            this.pixelMultiplier = pixelMultiplier;

            this.interfaceSize = interfaceSize;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

        private static bool IsPapyTexture(byte r, byte g, byte b)

        {

            // red between 208 and 244

            // 240 and 255

            // green between 192 and 237

            // 223 and 248

            // blue between 145 and 205

            // 178 and 228

            //return ((r > 0xD0) && (g >= 0xC0) && (b >= 0x91)) &&

            //       ((r < 0xF4) && (g <= 0xED) && (b <= 0xCD));

            return ((r >= 0xF0) && (r <= 0xFF) && (g >= 0xDF) && (g <= 0xF8) && (b >= 0xB2) && (b <= 0xE4));

        }

        public void SetPixelMultiplier(int pixelMultiplier)

        {

            this.pixelMultiplier = pixelMultiplier;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth      = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth    = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing    = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing  = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing   = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth  = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

        public void SetInterfaceSize(InterfaceSize interfaceSize)

        {

            this.interfaceSize = interfaceSize;

            swatchHeight = SWATCH_HEIGHT[(int)interfaceSize] * pixelMultiplier;

            swatchWidth = SWATCH_WIDTH[(int)interfaceSize] * pixelMultiplier;

            colorBarWidth = COLOR_BAR_WIDTH[(int)interfaceSize] * pixelMultiplier;

            redBarSpacing = RED_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            greenBarSpacing = GREEN_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            blueBarSpacing = BLUE_BAR_SPACING[(int)interfaceSize] * pixelMultiplier;

            swatchTestWidth = SWATCH_TEST_WIDTH[(int)interfaceSize] * pixelMultiplier;

        }

        unsafe private void ColorAt(byte *pixBytes, int x, int y, int stride, out byte r, out byte g, out byte b)

        {

            int pixelStart = (y * stride) + (x * 3);

                    r = pixBytes[pixelStart];

                    g = pixBytes[pixelStart + 1];

                    b = pixBytes[pixelStart + 2];

        }

        private bool IsDarkPixel(int r, int g, int b)

        {

            return ((r < 0x46) && (g < 0x46) && (b < 0x47));

        }

        private bool IsColorMatch(byte test_r, byte test_g, byte test_b, byte target_r, byte target_g, byte target_b)

        {

            return ((Math.Abs(test_r - target_r) <= COLOR_TOLERANCE) &&

                (Math.Abs(test_g - target_g) <= COLOR_TOLERANCE) &&

                (Math.Abs(test_b - target_b) <= COLOR_TOLERANCE));

        }

        unsafe private bool IsPossibleSwatchSlice(byte* pixBytes, int x, int y, int stride)

        {

            int testPixelStart = (y * stride) + (x * 3);

            byte r = pixBytes[testPixelStart];

            byte g = pixBytes[testPixelStart+1];

            byte b = pixBytes[testPixelStart+2];

            bool isDarkPixel = false;

            //bool isPapyAbove = false;

            //bool isPapyBelow = false;

            // 1.) Check if the top pixel is a dark pixel.

            isDarkPixel = IsDarkPixel(r, g, b); // ((r < 0x46) && (g < 0x46) && (b < 0x46));

            //// 2.) Check the pixel above it to see if it's from the papy texture.

            //int otherPixelStart = testPixelStart - stride;

            //isPapyAbove = ((otherPixelStart >= 0) &&

            //    IsPapyTexture(pixBytes[otherPixelStart++], pixBytes[otherPixelStart++], pixBytes[otherPixelStart]));

            //// 3.) Check the pixel below where the swatch should be to see if it's also from the papy texture.

            //otherPixelStart = testPixelStart + (stride * swatchHeight);

            //isPapyBelow = (IsPapyTexture(pixBytes[otherPixelStart++], pixBytes[otherPixelStart++], pixBytes[otherPixelStart]));

            //bool result = isDarkPixel && isPapyAbove && isPapyBelow;

            bool result = isDarkPixel;

            // grab the swatch color

            int swatchColorStart = testPixelStart + (2 * pixelMultiplier * stride); // 2 rows below the test pixel, skipping the faded color

            r = pixBytes[swatchColorStart];

            g = pixBytes[swatchColorStart+1];

            b = pixBytes[swatchColorStart+2];

            // scan the column from 2 below the top to 2 above the bottom to ensure the color matches

            for (int i = (2*pixelMultiplier); result && (i < swatchHeight-(2*pixelMultiplier)); ++i)

            {

                int otherPixelStart = testPixelStart + (stride * i);

                result &= IsColorMatch(pixBytes[otherPixelStart], pixBytes[otherPixelStart+1], pixBytes[otherPixelStart+2], r, g, b);

            }

            if (!result)

            {

                WriteLog("Swatch slice at {0}, {1} failed to match", x, y);

            }

            return result;

        }

        unsafe private bool IsPossibleSwatchUpperLeft(byte* pixBytes, int x, int y, int stride)

        {

            int testPixelStart = (y * stride) + (x * 3);

            if (testPixelStart < stride)

            {

                return false;

            }

            bool result = true;

            int solidLowerLeft = testPixelStart + ((swatchHeight - 4) * stride);

            int solidUpperRight = testPixelStart + ((swatchWidth - 4) * 3);

            int solidLowerRight = solidLowerLeft + ((swatchWidth - 4) * 3);

            byte swatch_r = pixBytes[solidUpperLeft];

            byte swatch_g = pixBytes[solidUpperLeft + 1];

            byte swatch_b = pixBytes[solidUpperLeft + 2];

            // Check the other 3 corners of the swatch size for color match

            result &= IsColorMatch(swatch_r, swatch_r, swatch_r, pixBytes[solidUpperRight], pixBytes[solidUpperRight + 1], pixBytes[solidUpperRight + 2]);

            result &= IsColorMatch(swatch_r, swatch_r, swatch_r, pixBytes[solidLowerLeft], pixBytes[solidLowerLeft + 1], pixBytes[solidLowerLeft + 2]);

            result &= IsColorMatch(swatch_r, swatch_r, swatch_r, pixBytes[solidLowerRight], pixBytes[solidLowerRight + 1], pixBytes[solidLowerRight + 2]);

            if (!result)

            {

                return false;

            }

            // scan down the right and left sides

            for (int yOff = 1; yOff < (swatchHeight - 5); ++yOff)

            {

                int testPixel = solidUpperLeft + (yOff * stride);

                result &= IsColorMatch(swatch_r, swatch_r, swatch_r, pixBytes[testPixel], pixBytes[testPixel + 1], pixBytes[testPixel + 2]);

                testPixel += ((swatchWidth - 1) * (x + 3));

                result &= IsColorMatch(swatch_r, swatch_r, swatch_r, pixBytes[testPixel], pixBytes[testPixel + 1], pixBytes[testPixel + 2]);

            }

            if (!result)

            {

                WriteLog("Failed to find left edge for potential swatch of color {2}, {3}, {4} at {0}, {1}", x, y, swatch_r, swatch_g, swatch_b);

                return false;

            }

            // test the left edge for dark pixels

            int i = 0;

            for (i = 0; result && (i < swatchHeight-pixelMultiplier); ++i)

            {

                int otherPixelStart = testPixelStart + (stride * i);

                result &= IsDarkPixel(pixBytes[otherPixelStart], pixBytes[otherPixelStart+1], pixBytes[otherPixelStart+2]);

            }

            if (!result)

            {

                // No dark border on the left side

                WriteLog("Failed to find left border for potential swatch of color {2}, {3}, {4} at {0}, {1}", x, y, swatch_r, swatch_g, swatch_b);

                return false;

            }

            // test the dark top border and for papyrus above and below the swatch

            bool borderError = false;

            int papyErrorCount = 0;

            for (i = 0; result && (i < swatchWidth); ++i)

            {

                int otherPixelStart = testPixelStart + (3 * i);

                bool isBorder = IsDarkPixel(pixBytes[otherPixelStart], pixBytes[otherPixelStart+1], pixBytes[otherPixelStart+2]);

                result &= isBorder;

                if (!isBorder)

                {

                    borderError = true;

                }

                if (otherPixelStart >= stride)

                {

                    otherPixelStart = otherPixelStart - stride;

                    papyErrorCount += (IsPapyTexture(pixBytes[otherPixelStart], pixBytes[otherPixelStart + 1], pixBytes[otherPixelStart + 2]) ? 0 : 1);

                }

                else

                {

                    papyErrorCount++;

                }

                // Checking along the bottom of the swatch - 

                otherPixelStart = testPixelStart + (stride * swatchHeight) + (3 * i);

                papyErrorCount += (IsPapyTexture(pixBytes[otherPixelStart], pixBytes[otherPixelStart+1], pixBytes[otherPixelStart+2]) ? 0 : 1);

            }

            result &= (papyErrorCount < (swatchWidth / 20)); // allow up to 5% error rate checking for papy texture, because this seems to be inconsistent

            if (!result && ((i > (swatchWidth*0.8)) || (papyErrorCount >= (swatchWidth/20))))

            {

                if (!borderError && (papyErrorCount < swatchWidth))

                {

                    WriteLog("Found a potential swatch candidate of width {0} at {1},{2} that had {3} failures matching papyrus texture", i, x, y, papyErrorCount);

                }

            }

            return result;

        }

        unsafe private bool TestPosition(int x, int y, byte* pixBytes, int screenshotWidth, int screenshotHeight, int stride, ref PaintColor reactedColor, ref int redPixelStart)

        {

            byte pixel_r, pixel_g, pixel_b;

            int pixelStart, otherPixelStart;

            bool colorMatch = true;

            // Look for the color swatch.

            pixelStart = (y * stride) + (x * 3);

            pixel_r = pixBytes[pixelStart];

            pixel_g = pixBytes[pixelStart + 1];

            pixel_b = pixBytes[pixelStart + 2];

            // Check 4 corners of solid area and left/right solid bar areas

            bool foundSwatch = IsPossibleSwatchUpperLeft(pixBytes, x, y, stride); // ((pixel_r < 0x46) && (pixel_g < 0x46) && (pixel_b < 0x46));

            if (foundSwatch)

            {

                int borderXOffset = 0;

                for (borderXOffset = (2 * pixelMultiplier); foundSwatch && (borderXOffset < swatchTestWidth); ++borderXOffset)

                {

                    foundSwatch &= IsPossibleSwatchSlice(pixBytes, x + borderXOffset, y, stride);

                    foundSwatch &= IsPossibleSwatchSlice(pixBytes, x + swatchWidth - borderXOffset, y, stride);

                }

            }

            if (foundSwatch)

            {

                // found a swatch with an appropriate dark top border with papyrus texture above it and papyrus a jump below it

                // 4.) Scan the left border of the potential swatch

                // location.

                colorMatch = true;

                for (int i = 2; i < swatchHeight - (2 * pixelMultiplier); ++i)

                {

                    otherPixelStart = pixelStart + (stride * i);

                    if (!IsColorMatch(pixel_r, pixel_g, pixel_b, pixBytes[otherPixelStart], pixBytes[otherPixelStart + 1], pixBytes[otherPixelStart + 2]))

                    {

                        colorMatch = false;

                        break;

                    }

                }

                if (colorMatch)

                {

                    // WE FOUND THE SWATCH!

                    // Now we know where the color bars are.

                    redPixelStart = pixelStart + (redBarSpacing * stride);

                    int redPixel = redPixelStart;

                    int redPixelCount = 0;

                    while ((pixBytes[redPixel] > 0x9F) &&

                           (pixBytes[redPixel + 1] < 0x62) &&

                           (pixBytes[redPixel + 2] < 0x62))

                    {

                        redPixelCount++;

                        // pixBytes[redPixel] = 0x00;

                        // pixBytes[redPixel + 1] = 0xFF;

                        // pixBytes[redPixel + 2] = 0xFF;

                        redPixel += 3;

                    }

                    WriteLog("Color {0}, {1}, {2} is no longer red at {3},{4}", pixBytes[redPixel], pixBytes[redPixel + 1], pixBytes[redPixel + 2], (redPixel % stride)/3, redPixel / stride);

                    reactedColor.Red = (byte)Math.Round((float)redPixelCount * 255f / (float)colorBarWidth);

                    int greenPixelStart = pixelStart + (greenBarSpacing * stride);

                    int greenPixelCount = 0;

                    while ((pixBytes[greenPixelStart] < 0x62) &&

                           (pixBytes[greenPixelStart + 1] > 0x9F) &&

                           (pixBytes[greenPixelStart + 2] < 0x62))

                    {

                        greenPixelCount++;

                        // pixBytes[greenPixelStart] = 0x00;

                        // pixBytes[greenPixelStart + 1] = 0xFF;

                        // pixBytes[greenPixelStart + 2] = 0xFF;

                        greenPixelStart += 3;

                    }

                    WriteLog("Color {0}, {1}, {2} is no longer green at pixel offset {3},{4}", pixBytes[greenPixelStart], pixBytes[greenPixelStart + 1], pixBytes[greenPixelStart + 2], (greenPixelStart % stride)/3, greenPixelStart / stride);

                    reactedColor.Green = (byte)Math.Round((float)greenPixelCount * 255f / (float)colorBarWidth);

                    int bluePixelStart = pixelStart + (blueBarSpacing * stride);

                    int bluePixelCount = 0;

                    while ((pixBytes[bluePixelStart] < 0x62) &&

                        (pixBytes[bluePixelStart + 1] < 0x62) &&

                        (pixBytes[bluePixelStart + 2] > 0x9F))

                    {

                        bluePixelCount++;

                        // pixBytes[bluePixelStart] = 0x00;

                        // pixBytes[bluePixelStart + 1] = 0xFF;

                        // pixBytes[bluePixelStart + 2] = 0xFF;

                        bluePixelStart += 3;

                    }

                    WriteLog("Color {0}, {1}, {2} is no longer blue at pixel offset {3},{4}", pixBytes[bluePixelStart], pixBytes[bluePixelStart + 1], pixBytes[bluePixelStart + 2], (bluePixelStart % stride)/3, bluePixelStart / stride);

                    reactedColor.Blue = (byte)Math.Round((float)bluePixelCount * 255f / (float)colorBarWidth);

                    WriteLog("Found the color swatch at {0}, {1}. Color={2} Red={3}px Green={4}px Blue={5}px", x, y, reactedColor, redPixelCount, greenPixelCount, bluePixelCount);

                    return true;

                }

            }

            return false;

        }

        unsafe public bool CaptureReaction(byte* pixBytes, int screenshotWidth, int screenshotHeight, int stride)

        {

            PaintColor reactedColor = new PaintColor();

            int redPixelStart = 0;

            ScreenWidth = screenshotWidth;

            ScreenHeight = screenshotHeight;

            IsCaptured = false;

            _recordedColor.Clear();