export function formatRemotes(remotes: string[]) : string[] {
  const process = R.compose(
    R.uniq,
    R.map(R.replace(/\/$/, '')),
    R.reject(R.isEmpty),
    R.map(R.replace(/\n/, '')),
    R.map(R.trim),
    R.map(rem => rem.replace(/\/\/(.+)@github/, '//github')),
    R.map(rem =>
      rem.match(/github\.com/)
        ? rem.replace(/\.git(\b|$)/, '')
        : rem),
    R.reject(R.isNil),
    R.map(rem => {
      if (rem.match(/^https?:/)) {
        return rem.replace(/\.git(\b|$)/, '');
      } else if (rem.match(/@/)) {
        return 'https://' +
          rem
            .replace(/^.+@/, '')
            .replace(/\.git(\b|$)/, '')
            .replace(/:/g, '/');
      } else if (rem.match(/^ftps?:/)) {
        return rem.replace(/^ftp/, 'http');
      } else if (rem.match(/^ssh:/)) {
        return rem.replace(/^ssh/, 'https');
      } else if (rem.match(/^git:/)) {
        return rem.replace(/^git/, 'https');
      }
    })
  );

  return process(remotes);
}

export const companyReducer: ActionReducer<any> = (state: CompanyState = INITIAL_STATE, action: Action) => {
	switch (action.type) {
		case CompanyAction.CHILD_ADDED:
			state.entities = state.entities || [];
			return Object.assign({ }, state, {
				entities: [...state.entities, process(action.payload)]
			});

		case CompanyAction.CHILD_CHANGED:
			state.entities = state.entities || [];
			return Object.assign({ }, state, {
				entities: [...R.reject(R.propEq('$key', action.payload.$key))(state.entities),
				process(action.payload)]
			});

		case CompanyAction.CHILD_REMOVED:
			state.entities = state.entities || [];
			return Object.assign({ }, state, {
				entities: R.reject(R.propEq('$key', action.payload.$key))(state.entities)
			});

		case CompanyAction.LOAD:
			return Object.assign({ }, state, {
				entities: undefined,
			});

		case CompanyAction.SELECT:
			return Object.assign({ }, state, {
				selected: action.payload
			});

		default:
		  return state;
	}
}

 /**
  * Return a clean part of the model for updating to database
  */
 static clean(model) {
   const removeComputedProps = R.pipe(
     R.mapObjIndexed((x , key) => {
       if (key.indexOf('$') >= 0) { return undefined }
       return x;
     }),
     R.reject(R.isNil)
   );
   const trimValues = R.map(n => { return R.is(String, n) ? R.trim(n) : n });
   const removeNullFields = R.reject(R.isNil)
   return R.pipe(removeComputedProps, trimValues, removeNullFields)(model);
 }

    /**
     * Sends all subscribed values to the Reactotron app.
     *
     * @param node The tree to grab the state data from
     */
    function sendSubscriptions(state: any) {
      // this is unreadable
      const changes = pipe(
        map(when(isNil, always(""))) as any,
        filter(endsWith(".*")),
        map((key: string) => {
          const keyMinusWildcard = slice(0, -2, key)
          const value = dotPath(keyMinusWildcard, state)
          if (is(Object, value) && !isNilOrEmpty(value)) {
            return pipe(keys, map(key => `${keyMinusWildcard}.${key}`))(value)
          }
          return []
        }) as any,
        concat(map(when(isNil, always("")), subscriptions)),
        flatten,
        reject(endsWith(".*")) as any,
        uniq as any,
        sortBy(identity) as any,
        map((key: string) => ({
          path: key,
          value: isNilOrEmpty(key) ? state : dotPath(key, state),
        })),
      )(subscriptions)

      reactotron.stateValuesChange(changes)
    }

export const clean = (obj) => {
	const nilEmpty: any = R.mapObjIndexed((x , key) => (R.isEmpty(x)) ? undefined : x);
	const nilComputed: any = R.mapObjIndexed((x , key) => (key.indexOf('$') >= 0) ? undefined : x);
	const trimProps = R.map((n: any) => R.is(String, n) ? R.trim(n) : n);
	const cleanNil = R.reject(R.isNil);
	return R.pipe(nilEmpty, nilComputed, trimProps, cleanNil)(obj);
}

export const sendEmail$ = (applicant) => {
	const cc = '[email protected]';
	const array = R.reject(R.isNil)([
		applicant.hasSps ? 'SPS' : null,
		applicant.hasSrp ? 'SRP' : null,
		applicant.hasSrpSupervisor ? 'SRP Approved Supervisor' : null,
	]);
	const applicantText = R.reduce((a, n) => (a === '') ? n : `${a}, ${n}`, '')(array);
	const text = `<p>Dear ${applicant.applicantName}</p><p>We have received your ${applicantText} applicant package.</p><p>We will keep you updated on the progress.</p><p>Thank you</p>`;

	return this.mailgun.send$(`${applicant.applicantEmail}`, 'Applicant Received', text, cc)
		.first()
		.catch(err => {
			console.log(err);
			return Observable.of(err)
		})
}

export function getAllRemotes(exec, projectPath: string) : Promise<string[]> {
  const process = R.compose(
    R.uniq,
    R.map(R.head),
    R.map(R.split(' ')),
    R.reject(R.isEmpty),
    R.map(R.last),
    R.map(R.split(/\t/)),
    R.split('\n')
  );

  return new Promise((resolve, reject) => {
    exec('git remote -v', { cwd: projectPath }, (error, stdout, stderr) => {
      if (stderr || error) return reject(stderr || error);
      resolve(process(stdout));
    });
  });
}

export function* getFirstBookmarkTree(options: Partial<Options>): SagaIterator {
  const [firstTreeInfo, rootFolders]: [BookmarkTree, Array<BookmarkInfo>] = yield all([
    call(getBookmarkTree, String(options[CST.OPTIONS.DEF_EXPAND])),
    call(getBookmarkChildren, CST.ROOT_ID)
  ])
  return {
    ...firstTreeInfo,
    children: [
      ...R.reject((bookmarkInfo) => {
        const idNumber = Number(bookmarkInfo.id)
        return (
          idNumber === options[CST.OPTIONS.DEF_EXPAND] ||
          (options[CST.OPTIONS.HIDE_ROOT_FOLDER] || []).includes(idNumber)
        )
      }, rootFolders),
      ...firstTreeInfo.children
    ]
  }
}

  static clean(required, strings, floats, data) {
    const rejectEmpty = R.reject(n => R.isEmpty(n[required]));

    const cleanStrings = R.map(n => {
      n[strings] = R.trim(n[strings]);
      return n;
    });

    const cleanFloats = R.map(n => {
      n[floats] = parseFloat(n[floats]);
      return n;
    });

    const clean = R.pipe(rejectEmpty,
      cleanStrings,
      cleanFloats
    );

    return clean(data);
  }

 return R.map(updateItem(itemId, (it: ITodoItem) =>
     R.merge(it, { states: R.reject(R.eq(state), it.states) })), items);