/**
 * Copyright 2005-2015 The Kuali Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
 *
 * 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.
 */
package org.kuali.rice.testtools.selenium;

import org.junit.*;
import org.kuali.rice.testtools.common.JiraAwareFailable;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriverService;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author Kuali Rice Team (rice.collab@kuali.org)
 * @deprecated see WebDriverAftBase
 */
@Deprecated
public abstract class WebDriverITBase {

    public WebDriver driver;
    static ChromeDriverService chromeDriverService;

    /**
     * Returns the URL to be used with this test
     *
     * @return URL of the test
     */
    public abstract String getTestUrl();

    /**
     * Override in test to define a user other than admin
     * @return
     */
    public String getUserName() {
        return "admin";
    }

    @BeforeClass
    public static void createAndStartService() throws Exception {
        chromeDriverService = WebDriverUtils.chromeDriverCreateCheck();
        if (chromeDriverService != null) chromeDriverService.start();
    }


    /**
     * <p>
     * Logs in using the KRAD Login Page, if the JVM arg remote.autologin is set, auto login as admin will not be done.
     * </p>
     *
     * @param driver to login with
     * @param userName to login with
     * @param failable to fail on if there is a login problem
     * @throws InterruptedException
     */
    public void login(WebDriver driver, String userName, JiraAwareFailable failable) throws InterruptedException {
        if ("true".equalsIgnoreCase(System.getProperty(WebDriverUtils.REMOTE_AUTOLOGIN_PROPERTY, "true"))) {
            driver.findElement(By.name("login_user")).clear();
            driver.findElement(By.name("login_user")).sendKeys(userName);
            driver.findElement(By.id("Rice-LoginButton")).click();
            Thread.sleep(1000);
            String contents = driver.getPageSource();
            AutomatedFunctionalTestUtils.failOnInvalidUserName(userName, contents, failable);
            AutomatedFunctionalTestUtils.checkForIncidentReport(driver.getPageSource(), "Login",
                    "Login failure", failable);
        }
    }

    public void fail(String message) { // should this method be abstract or overridden, no jira aware fail?
        Assert.fail(message);
    }

    /**
     * Setup the WebDriver test, login and load the tested web page
     *
     * @throws Exception
     */
    @Before
    public void setUp() throws Exception {
        driver = WebDriverUtils.setUp(this.getClass().getSimpleName(), "DeprecatedWebDriverItBaseTest");

        WebDriverUtils.openTestUrl(driver, WebDriverUtils.getBaseUrlString() + "/" + getTestUrl());

        login(driver, getUserName(), new JiraAwareFailable() {
            @Override
            public void fail(String message) {
                Assert.fail(message);
            }

            @Override
            public void jiraAwareFail(String message) {
                Assert.fail(message);
            }

            @Override
            public void jiraAwareFail(String contents, String message) {
                Assert.fail(contents + " " + message);
            }

            @Override
            public void jiraAwareFail(String contents, String message, Throwable throwable) {
                Assert.fail(contents + " " + message + " " + throwable.getMessage());
            }
        });
    }

    /**
     * Tear down the WebDriver test
     *
     * @throws Exception
     */
    @After
    public void tearDown() throws Exception {
        if (WebDriverUtils.dontTearDownPropertyNotSet()) {
            if (driver != null) {
                driver.quit(); // TODO not tested with chrome, the service stop might need this check too
            } else {
                System.out.println("WebDriver was null in WebDriverUtils.tearDown()");
            }
        }
    }

    /**
     * Tear down the WebDriver test
     *
     * @throws Exception
     */
    @AfterClass
    public static void stopService() throws Exception {
        if (chromeDriverService != null) {
            chromeDriverService.stop();
        }
    }

    /**
     * Check if an element is present
     *
     * <p>
     * This test takes a while due to the 'implicit wait' time.
     * </p>
     *
     * @param by The locating mechanism of the element
     * @return true if the element is present, false otherwise
     */
    public boolean isElementPresent(By by) {
        if (driver.findElements(by).isEmpty()) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * Quickly check if an element is present
     *
     * <p>
     * Just like {@link #isElementPresent(org.openqa.selenium.By)} but with a short 'implicit wait' time.  Use this only
     * if it is guaranteed that all elements are rendered.
     * </p>
     *
     * @param by The locating mechanism of the element
     * @return true if the element is present, false otherwise
     */
    public boolean isElementPresentQuick(By by) {
        driver.manage().timeouts().implicitlyWait(WebDriverUtils.IMPLICIT_WAIT_TIME_LOOP_MS, TimeUnit.MILLISECONDS);
        boolean result = isElementPresent(by);
        driver.manage().timeouts().implicitlyWait(WebDriverUtils.IMPLICIT_WAIT_TIME_SECONDS_DEFAULT, TimeUnit.SECONDS);
        return result;
    }

    /**
     * Assert that clicking an element causes a popup window with a specific URL
     *
     * @param by The locating mechanism of the element to be clicked
     * @param windowName The name of the popup window
     * @param url The URL of the popup window
     */
    public void assertPopUpWindowUrl(By by, String windowName, String url) {
        driver.findElement(by).click();
        String parentWindowHandle = driver.getWindowHandle();
        // wait page to be loaded
        driver.switchTo().window(windowName).findElements(By.tagName("head"));
        Assert.assertEquals(url, driver.getCurrentUrl());
        driver.switchTo().window(parentWindowHandle);
    }
    
    /**
     * 
     *
     * @param by The locating mechanism of the element
    */
    protected void waitFor(By by) throws InterruptedException {
        waitFor(by, "");
    }

    /**
     * TODO Investigate using WebDriverUtils.waitFor
     *
     * @param by The locating mechanism of the element
     * @param message User defined message to display
     */
    protected void waitFor(By by, String message) throws InterruptedException {
        Thread.sleep(1000);
        try {
            driver.findElement(by);
        } catch (Exception e) {
            // ignore, fail on use if required
        }
    }

    /**
     * 
     *
     * @param by The locating mechanism of the element
     * @param text The text to type
    */
    protected void waitAndType(By by, String text) throws InterruptedException {
        waitFor(by, "");
        try {
            (driver.findElement(by)).sendKeys(text);
        } catch (Exception e) {
            fail(e.getMessage() + " " + by.toString() + " " + text);
            e.printStackTrace();
        }
    }
    
    /**
     * 
     *
     * @param by The locating mechanism of the element
     * @param text The text to type
     * @param message User defined message to display
    */
    protected void waitAndType(By by, String text, String message) throws InterruptedException {
        waitFor(by, "");
        try {
            (driver.findElement(by)).sendKeys(text);
        } catch (Exception e) {
            fail(e.getMessage() + " " + by.toString() + " " + text + "  "+message);
            e.printStackTrace();
        }
    }
    
    /**
     * 
     *
     * @param locator The locating mechanism of the element
     * @param text The text to type
    */
    protected void waitAndTypeByXpath(String locator, String text) throws InterruptedException {
        waitAndType(By.xpath(locator), text);
    }
    
    /**
     * 
     *
     * @param locator The locating mechanism of the element
     * @param text The text to type
     * @param message User defined message to display
    */
    protected void waitAndTypeByXpath(String locator, String text, String message) throws InterruptedException {
        waitAndType(By.xpath(locator), text, message);
    }
    
    /**
     * 
     *
     * @param name The name of the element
     * @param text The text to type
    */
    protected void waitAndTypeByName(String name, String text) throws InterruptedException {
        waitAndType(By.name(name), text);
    }
    
    /**
     * Clear the text written in an input field by name of an element
     *
     * @param name The name of the element
    */
    protected void clearTextByName(String name) throws InterruptedException {
        clearText(By.name(name));
    }
    
    /**
     * Clear the text written in an input field by xpath of an element
     *
     * @param locator The locating mechanism of the element
    */
    protected void clearTextByXpath(String locator) throws InterruptedException {
        clearText(By.xpath(locator));
    }
    
    /**
     * Clear the text written in an input field by xpath of an element
     *
     * @param by method used for finding the element
    */
    protected void clearText(By by)  throws InterruptedException {
        driver.findElement(by).clear();        
    }
    
    /**
     * Dismiss the javascript alert (clicking Cancel)
     *
    */
    protected void dismissAlert()
    {
        Alert alert = driver.switchTo().alert();
        //update is executed
        alert.dismiss();
    }
    
    /**
     * Accept the javascript alert (clicking OK)
     *
    */
    protected void acceptAlert()
    {
        Alert alert = driver.switchTo().alert();
        //update is executed
        alert.accept();
    }
    
    protected String getEval(String script)
    {
        JavascriptExecutor js = (JavascriptExecutor) driver;
        return (String)js.executeScript(script);
    }
    
    /**
     * Switch to new window
     *
    */
    protected void switchWindow()
    {
        Set<String> winSet = driver.getWindowHandles();
        List<String> winList = new ArrayList<String>(winSet);
        String newTab = winList.get(winList.size() - 1);
        driver.switchTo().window(newTab);
    }
    
    /**
     * Get value of any attribute by using element name
     *
     *@param name name of an element
     *@param attribute the name of an attribute whose value is to be retrieved
    */
    protected String getAttributeByName(String name,String attribute) throws InterruptedException {
        return getAttribute(By.name(name),attribute);
    }
    
    /**
     * Get value of any attribute by using element xpath
     *
     *@param locator locating mechanism of an element
     *@param attribute the name of an attribute whose value is to be retrieved
    */
    protected String getAttributeByXpath(String locator,String attribute) throws InterruptedException {
        return getAttribute(By.xpath(locator),attribute);
    }
    
    /**
     * Get value of any attribute of an element
     *
     * @param by method used for finding the element
     *@param attribute the name of an attribute whose value is to be retrieved
    */
    protected String getAttribute(By by,String attribute)  throws InterruptedException {
        return driver.findElement(by).getAttribute(attribute);        
    }
    
    /**
     * 
     *
     * @param text text of the link
    */
    protected void waitAndClickByLinkText(String text) throws InterruptedException {
        waitAndClick(By.linkText(text),"");
    }

    /**
     * 
     *
     * @param text text of the link
     * @param message user defined message to display
    */
    protected void waitAndClickByLinkText(String text, String message) throws InterruptedException {
        waitAndClick(By.linkText(text), message);
    }
    
    /**
     * 
     *
     * @param by method used for finding the element
    */
    protected void waitAndClick(By by) throws InterruptedException {
        waitAndClick(by, "");
    }

    /**
     * 
     *
     * @param by method used for finding the element
     * @param message user defined message to display
    */
    protected void waitAndClick(By by, String message) throws InterruptedException {
        waitFor(by, message);
        try {
            (driver.findElement(by)).click();
        } catch (Exception e) {
            fail(e.getMessage() + " " + by.toString() + " " + message);
        }
    }

    /**
     * 
     *
     * @param locator mechanism to locate element by xpath
    */
    protected void waitAndClick(String locator) throws InterruptedException {
        waitAndClick(locator, "");
    }
    
    /**
     * 
     *
     * @param locator mechanism to locate element by xpath
     * @param message user defined message to display
    */
    protected void waitAndClick(String locator, String message) throws InterruptedException {
        waitAndClick(By.cssSelector(locator), message);
    }

    /**
     * 
     *
     * @param locator mechanism to locate element by xpath
    */
    protected void waitForElementPresent(String locator) throws InterruptedException {
        waitFor(By.cssSelector(locator));
    }

    /**
     * 
     *
     * @param locator mechanism to locate element by xpath
    */    
    protected void waitForElementPresentByXpath(String locator) throws InterruptedException {
        waitFor(By.xpath(locator));
    }
    
    /**
     * 
     *
     * @param name name of an element
    */ 
    protected void waitForElementPresentByName(String name) throws InterruptedException {
        waitFor(By.name(name));
    }
    
    protected void checkForIncidentReport(JiraAwareFailable failable) {
        checkForIncidentReport("", failable, "");
    }

    protected void checkForIncidentReport(String locator, JiraAwareFailable failable) {
        checkForIncidentReport(locator, failable, "");
    }
    
    protected void checkForIncidentReport(String locator, JiraAwareFailable failable, String message) {
        AutomatedFunctionalTestUtils.checkForIncidentReport(driver.getPageSource(), locator, message, failable);
    }


}